Four Guys DSGP¶

Question¶

How to automatically switch notification mode on mobile phone by using sensory data collected from smartphone and smartwatch？

Data Source¶

http://extrasensory.ucsd.edu

Publicly available: everyone is invited to download the dataset for free and use it (conditioned on citing our original paper).

Data Preprocessing¶

Functions¶

In [1]:
import numpy as np
import gzip
import pandas as pd
from sklearn.impute import KNNImputer 
import os
import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
import random

parse_header_of_csv¶

This method take a dataframe as input, return the feature part and label part

In [2]:
def parse_header_of_csv(csv_df):
    # Isolate the headline columns:

    for (ci,col) in enumerate(csv_df.columns):
        # find the start of label column
            if col.startswith('label:'):
                first_label_ind = ci
                break
            pass
    # use the "start of label" find above to split feature and label
    feature_names = csv_df.columns[1:first_label_ind]
    label_names = list(csv_df.columns[first_label_ind:-1])

    # remove "label: " get pure label name
    for (li,label) in enumerate(label_names):
    # In the CSV the label names appear with prefix 'label:', but we don't need it after reading the data:
            assert label.startswith('label:')
            label_names[li] = label.replace('label:','')
            pass

    csv_df.rename(columns=dict(zip(csv_df.columns[first_label_ind:-1],label_names)),inplace=True)
        
    return (feature_names,label_names)

parse_body_of_csv¶

This method take a dataframe and number of features as input, return sensor matrix, label matrix, missing label matrix and timestamp matrix(index)

In [3]:
def parse_body_of_csv(csv_df,n_features):


    # Read the entire CSV body into a single numeric matrix:
    
    # Timestamp is the primary key for the records (examples):
    timestamps = csv_df.index
    # Read the sensor features:
    X = csv_df[csv_df.columns[0:n_features+1]]
    # Read the binary label values, and the 'missing label' indicators:
    trinary_labels_mat = csv_df[csv_df.columns[n_features+1:-1]] # This should have values of either 0., 1. or NaN

    M = pd.isna(trinary_labels_mat) # M is the missing label matrix
    Y = np.where(M,0,trinary_labels_mat) > 0. # Y is the label matrix

    
    return (X,Y,M,timestamps)

read_user_data¶

Read the data (precomputed sensor-features and labels) for a user.

This function assumes the user's data file is present.

this method take id of subject as input return sensor matrix, label matrix, missing label matrix and timestamp matrix(index) by calling parse_body_of_csv()method

In [4]:
def read_user_data(uuid):
    user_data_file = 'Datasets/%s.features_labels.csv.gz' % uuid

    with gzip.open(user_data_file,'rb') as fid:
        csv_df = pd.read_csv(fid,delimiter=',', index_col= 0)
        pass

    (feature_names,label_names) = parse_header_of_csv(csv_df)
    n_features = len(feature_names)
    (X,Y,M,timestamps) = parse_body_of_csv(csv_df,n_features)

    return (X,Y,M,timestamps,feature_names,label_names)

get_df_list¶

by calling this method we can get a list of dataframe which contain all the user's sensor data

3.6 v0 may get label lists later w.

Author chen

In [5]:
def get_df_list():
    #To create uuid_list which includes all uuid
    uuid_list = []
    f = open('UUID List.txt', 'r')
    for line in f.readlines():
        uuid_list.append(line.strip())

    main_feature = []
    f = open('Main Feature.txt', 'r')
    for line in f.readlines():
        main_feature.append(line.strip())

    instance = []
    # Run all uuid
    for i in range(len(uuid_list)):    
        (X,Y,M,timestamps,feature_names,label_names) = read_user_data(uuid_list[i])

        # Create dataframe for all Main Feature value
        Main_X = pd.DataFrame(X.loc[:,X.columns.str.startswith(main_feature[0])], columns = [main_feature[0]])
        for j in range(1,len(main_feature)):
            Main_X = pd.concat([Main_X, X.loc[:,X.columns.str.startswith(main_feature[j])]], axis=1)
        instance.append(Main_X)
    return instance

get_df¶

For getting single user data to dataframe.

In [6]:
def get_df(uuid):
    main_feature = []
    f = open('Main Feature.txt', 'r')
    for line in f.readlines():
        main_feature.append(line.strip())

    # Run all uuid 
    (X,Y,M,timestamps,feature_names,label_names) = read_user_data(uuid)

    # Create dataframe for all Main Feature value
    Main_X = pd.DataFrame(X.loc[:,X.columns.str.startswith(main_feature[0])], columns = [main_feature[0]])
    for j in range(1,len(main_feature)):
        Main_X = pd.concat([Main_X, X.loc[:,X.columns.str.startswith(main_feature[j])]], axis=1)
    return Main_X

data_imputer¶

by calling these two methods we can fill the null values of feature data.

  1. $non\_ watch\_ value\_ imputer$ is use the mean value to fill the feature data from sensors except watch sensors.
  2. $KNN\_ for \_ watch \_ data$ is use K nearest neighour to fill the feature data from watch.
In [7]:
def non_watch_value_imputer(df):
    # get the data except watch
    non_watch_values = df.loc[:,(df.columns.str.startswith('watch_') == False)]
    valid_data = pd.DataFrame(columns = ['blank'])
    # use mean values to fill the none value
    for column in non_watch_values.columns:
        column_df = non_watch_values[column]
        mean_value = non_watch_values[column].mean()
        column_df = column_df.fillna(mean_value)
        valid_data = pd.concat([valid_data, column_df],axis=1,ignore_index=False)

    valid_data = valid_data[valid_data.columns[1:]]
    #combine the watch data
    combine_data = pd.concat([valid_data,df.loc[:,df.columns.str.startswith('watch_')]],axis=1,ignore_index=False)
    return combine_data

def KNN_for_watch_data(df,K):
    #input data and K neighbors
    imputer = KNNImputer(n_neighbors=K)
    df[list(df.columns)] = imputer.fit_transform(df)
    return df

pca_to_train_test¶

by calling this function, PCA can be applied to the pre-cleaned and splitted data.

return the processed data and pca components.

In [8]:
def pca_to_data(csv_df,n):

    pca = PCA(n_components=n)
    features = csv_df.loc[:,csv_df.columns.str.startswith('audio_naive')]
    new_features = pca.fit_transform(features)
    pca_components = pca.components_

    print('PCA explained variance ratio is', pca.explained_variance_ratio_.sum())

    new_feature_df = pd.DataFrame(data=new_features,index=csv_df.index,columns=['audio_naive:pc1','audio_naive:pc2'])
    other_features = csv_df.loc[:,(csv_df.columns.str.startswith('audio_naive') == False)]
    new_feature_df = pd.concat([other_features,new_feature_df],axis=1,ignore_index=False)


    return (new_feature_df, pca_components)

def pca_to_train_test(X_train, X_test, data):
    
    X_train = pd.DataFrame(X_train,columns=data.iloc[:,:-1].columns)
    X_test = pd.DataFrame(X_test,columns=data.iloc[:,:-1].columns)
    X_train_pca, projection = pca_to_data(X_train,2)

    audio_test = X_test.loc[:,X_test.columns.str.startswith('audio_naive')]
    X_test_pca = X_test.loc[:,X_test.columns.str.startswith('audio_naive')==False]
    projection_matrix = pd.DataFrame(np.dot(audio_test,projection.T),columns=['audio_naive:pc1','audio_naive:pc2'])
    X_test_pca = pd.concat([X_test_pca,projection_matrix],axis=1)
    return X_train_pca.values, X_test_pca.values

get_related_label¶

by calling this function, input wanted label

return counts of this label (For EDA)

In [9]:
def get_related_label(char):
    with gzip.open('cleaned_data.zip','rb') as data:
        data = pd.read_csv(data,index_col=[0,1])
    new_label_data = []
    for uuid in data.groupby('uuid').count().index:
        X,Y,M,timestamps,feature_names,label_names = read_user_data(uuid)
        label_dict = {v: k for k, v in dict(enumerate(label_names + ['None'])).items()}
        label_list = []
        for each in Y:
            if np.array(each).any()==False:
                continue
            else:
                new_label_names = np.array(label_names)[each]
                if char in new_label_names:
                    label_list.append(list(new_label_names))
    new_label_data = new_label_data + label_list
    labels = []
    for i in new_label_data:
        labels = labels + i
    l_dict = {}
    for key in labels:
        l_dict[key] = l_dict.get(key, 0) + 1
    return l_dict

splitdata¶

Input:
Final_data: dataframe
test_size: split ratio for testing dataset and validation dataset

Output:
x_train, y_train, x_val, y_val, x_test, y_test

This function will extract the input ratio data from every user's dataset as the testing dataset and validation dataset. The remaining data will be used as the training dataset. These datasets will be used for non-time series models.

In [10]:
def splitdata(Final_data,test_size):
    with gzip.open('cleaned_data.zip','rb') as data:
        data = pd.read_csv(data,index_col=[0,1])
    idlist = data.groupby('uuid').count().index
    
    stamps_index = {}
    for id in idlist:
        length = len(Final_data.loc[id])
        random.seed(777)
        stamps_index[id] = random.sample(range(0,length),int(length*test_size))

    train_data = pd.DataFrame()
    test_data = pd.DataFrame()

    for k, v in stamps_index.items():
        # Select testing data
        test_data = pd.concat([test_data, Final_data.loc[k].iloc[v]], axis = 0)
        
        # Remove testing data from original dataset
        total = Final_data.loc[k]
        remain = total[~total.isin(Final_data.loc[k].iloc[v])].dropna()
        
        # Remaining data are training data
        train_data = pd.concat([train_data, remain], axis = 0)
        
        # Shuffle training and testing data
        from sklearn.utils import shuffle
        test_data = shuffle(test_data)
    
        # Prepare testing data X and Y
        x_test = test_data.iloc[:,:-1].values
        y_test = test_data.iloc[:,-1].values.astype(int)

        # Prepare training data X and Y
        train_data_x = train_data.iloc[:,:-1].values
        train_data_y = train_data.iloc[:,-1].values.astype(int)
        
        # Split training and validation dataset
        from sklearn.model_selection import train_test_split
        x_train, x_val, y_train, y_val = train_test_split(train_data_x, train_data_y, test_size=0.15, shuffle=True)
    

    return x_train, y_train, x_val, y_val, x_test, y_test

TS_data¶

Input:
dataset: should be np.array
n_past: number of lags (timestamps back) to use for models
n_pred: steps ahead to forecast

Output:
X, Y: 3D tuple

This function will convert the time series array into X and Y tuple for the training of time series model.
The shape of X is (samples, timesteps, features).
samples — total number of sequences constructed for training.
timesteps — the length of the samples.
features — number of features used.

In [11]:
def TS_data(dataset, n_past, n_pred):
    # Counting the amount of features passed from the array 
    n_features = dataset.shape[1] - 1
    
    X, Y = [], []

    if len(dataset) - n_past <= 0:
        X.append(dataset)
    else:
        for i in range(len(dataset) - n_past - n_pred):
            Y.append(dataset[(i + n_past):(i + n_past + n_pred), -1])
            X.append(dataset[i:(i + n_past), 0:50])

    X, Y = np.array(X), np.array(Y)

    # Reshaping the X array to an RNN input shape 
    X = np.reshape(X, (X.shape[0], n_past, n_features))

    return X, Y

TS_split¶

Input:
Final_data: dataframe
n_past: number of lags (timestamps back) to use for models
n_pred: steps ahead to forecast

Output:
x_train, y_train, x_val, y_val, x_test, y_test

This function will randomly extracted data from 38 users as the training dataset, 7 users as the validation dataset, and another 7 users as the test dataset.
Then, convert the dataset into a dataset form acceptable to the recurrent neural network. Output datasets will be used for time series models.

In [12]:
def TS_split(Final_data, n_past, n_pred):
    import random
    with gzip.open('cleaned_data.zip','rb') as data:
        data = pd.read_csv(data,index_col=[0,1])
    idlist = data.groupby('uuid').count().index

    random.seed(505)
    randid = random.sample(list(range(0,len(idlist))), len(idlist))

    train_data = pd.DataFrame()
    validation_data = pd.DataFrame()
    test_data = pd.DataFrame()
    
    for i in randid[0:38]:
        train_data = pd.concat([train_data, Final_data.loc[idlist[i]]], axis = 0)
        
    for i in randid[38:45]:
        validation_data = pd.concat([validation_data, Final_data.loc[idlist[i]]], axis = 0)

    for i in randid[45:]:
        test_data = pd.concat([test_data, Final_data.loc[idlist[i]]], axis = 0)
    
    
    x_train, y_train = TS_data(train_data.values, n_past, n_pred)
    
    x_val, y_val = TS_data(validation_data.values, n_past, n_pred)
    
    x_test, y_test = TS_data(test_data.values, n_past, n_pred)
    
    return x_train, y_train, x_val, y_val, x_test, y_test

Data cleaning & Handling Missing Values¶

In [13]:
uuid_list = []
f = open('UUID List.txt', 'r')
for line in f.readlines():
    uuid_list.append(line.strip())
valid_data = pd.DataFrame()
for uuid in uuid_list:
    df = get_df(uuid)
    try:
        cleaned_data = non_watch_value_imputer(df)
        cleaned_data = KNN_for_watch_data(cleaned_data,10)
        muti_index = pd.MultiIndex.from_product([[uuid], cleaned_data.index], names=['uuid','timestamps'])
        cleaned_data = pd.DataFrame(cleaned_data.values, columns=cleaned_data.columns, index=muti_index)
        valid_data = pd.concat([valid_data,cleaned_data],axis=0,ignore_index=False)
    except:
        print(uuid,'failed to export')
valid_data.to_csv('cleaned_data.zip',mode = 'w',compression= 'gzip')

40E170A7-607B-4578-AF04-F021C3B0384A failed to export
61359772-D8D8-480D-B623-7C636EAD0C81 failed to export
61976C24-1C50-4355-9C49-AAE44A7D09F6 failed to export
7D9BB102-A612-4E2A-8E22-3159752F55D8 failed to export
CCAF77F0-FABB-4F2F-9E24-D56AD0C5A82F failed to export
ECECC2AB-D32F-4F90-B74C-E12A1C69BBE2 failed to export
F50235E0-DD67-4F2A-B00B-1F31ADA998B9 failed to export
FDAA70A1-42A3-4E3F-9AE3-3FDA412E03BF failed to export

Label Replacement¶

In [14]:
with gzip.open('cleaned_data.zip','rb') as data:
    data = pd.read_csv(data,index_col=[0,1])
main_label_list = [['SLEEPING'],
                   ['LAB_WORK', 'IN_CLASS', 'IN_A_MEETING', 'LOC_main_workplace','COMPUTER_WORK','AT_SCHOOL', 'WITH_CO-WORKERS'],
                   ['FIX_walking', 'FIX_running', 'BICYCLING','OR_exercise'],
                   ['COOKING', 'BATHING_-_SHOWER', 'CLEANING', 'DOING_LAUNDRY', 'WASHING_DISHES', 'TOILET', 'GROOMING', 'DRESSING','EATING'],
                   ['FIX_restaurant','SHOPPING', 'STROLLING', 'DRINKING__ALCOHOL_','WATCHING_TV', 'SURFING_THE_INTERNET', 'AT_A_PARTY', 'AT_A_BAR', 'LOC_beach', 'SINGING', 'WITH_FRIENDS'],                   
                   ['IN_A_CAR', 'ON_A_BUS', 'DRIVE_-_I_M_THE_DRIVER', 'DRIVE_-_I_M_A_PASSENGER','STAIRS_-_GOING_DOWN', 'ELEVATOR']]

new_label_list = ['sleep','efficiency','exercise','life_activity','entertainment','on_the_way']
new_label_dict = {'sleep':0, 'efficiency':1, 'exercise':2, 'life_activity':3, 'entertainment':4, 'on_the_way':5, 'Normal':6}
all_label_list = []

for i in main_label_list:
    all_label_list = all_label_list + i

new_label_data = pd.DataFrame()
for uuid in data.groupby('uuid').count().index:
    X,Y,M,timestamps,feature_names,label_names = read_user_data(uuid)
    label_pair = pd.DataFrame(
        columns = ['Label Name'],
        index = timestamps
    )
    s = Y.shape


    for i in range(0,s[0]):
        arr = np.where(Y[i]==1)
        temp = []
        for j in arr[0]:
            temp.append(label_names[j])
        label_pair.loc[timestamps[i], 'Label Name'] = temp

    new_label = []
    new_index = []
    for index in label_pair.index:
        label = label_pair.loc[index].values[0]
        if bool(label) == True:
            for num,status in enumerate(main_label_list):
                if bool(set(status) & set(label)):
                    new_label.append(num)
                    new_index.append(index)
                    break
                elif bool(set(label) & set(all_label_list)):
                    continue
                else:
                    new_label.append(new_label_dict['Normal'])
                    new_index.append(index)
                    break 

    muti_index = pd.MultiIndex.from_product([[uuid], new_index], names=['uuid','timestamps'])
    new_label = pd.DataFrame(data = new_label, index = muti_index,columns = ['Status'])
    new_label_data = pd.concat([new_label_data,new_label],axis=0,ignore_index=False)

new_label_data.to_csv('new_label_data.zip',mode = 'w',compression= 'gzip')

The standard division of all features using bar plot¶

In [15]:
"""
This method take a dataframe as input
plot a line plot where x axis is all the features, y axis is the std of that features
all the data has been normalized into [0,1] before plot

why 3.6
"""
def StdPlotNorm(df):
    from sklearn import preprocessing
    # get the std of each feature after normalized but all vary low so did not work

    df.dropna(axis=1,inplace=True)
    # df.info()
    nor = preprocessing.normalize(df)
    x = np.arange(0,df.shape[1])
    # need to be normalized if want to reduce dimention by filter std
    plt.figure(figsize=(20,5))
    # plt.bar(x,df.std(axis = 0))
    plt.bar(x,nor.std(axis = 0))
    plt.xlabel('features')
    plt.ylabel('standard devision')

StdPlotNorm(cleaned_data)

Feature selection¶

In [16]:
"""
this method take a dataframe as input
return the selected feature and the dataframe that only contain the selected feature 
the feature is selected according to the corralation matrix
"""
def SelectFeature(df):
    # clean the unnecessory feature
    colum = df.filter(regex = 'discrete:|lf_measurements:').columns
    df.drop(columns=colum,inplace=True)
    # get the corr matrix
    corrMatrix = df.corr()
    i = 0
    # feature paramater has all the feature that should be reserve
    feature = {"raw_acc:magnitude_stats:mean"}
    # reserve all the features that do not have high correlation with other features
    for index,row in corrMatrix.iterrows():
        for j in range(0,i):
            if row[j] > 0.7 or row[j] < -0.7:
                break
            if j == i-1:
                feature.add(index)
        i = i+1
    df = df.loc[:,feature]
    return df,feature

X,feature = SelectFeature(cleaned_data)
X.info()
# type(feature)

<class 'pandas.core.frame.DataFrame'>
Index: 4973 entries, 1443629160 to 1444235019
Data columns (total 22 columns):
 #   Column                           Non-Null Count  Dtype  
---  ------                           --------------  -----  
 0   audio_naive:mfcc8:mean           4973 non-null   float64
 1   audio_naive:mfcc0:mean           4973 non-null   float64
 2   proc_gyro:3d:mean_z              4973 non-null   float64
 3   audio_naive:mfcc10:mean          4973 non-null   float64
 4   audio_naive:mfcc4:mean           4973 non-null   float64
 5   raw_acc:3d:mean_y                4973 non-null   float64
 6   raw_acc:3d:mean_z                4973 non-null   float64
 7   proc_gyro:3d:mean_y              4973 non-null   float64
 8   audio_naive:mfcc5:mean           4973 non-null   float64
 9   audio_naive:mfcc3:mean           4973 non-null   float64
 10  raw_acc:magnitude_stats:mean     4973 non-null   float64
 11  proc_gyro:3d:mean_x              4973 non-null   float64
 12  audio_naive:mfcc6:mean           4973 non-null   float64
 13  raw_acc:3d:mean_x                4973 non-null   float64
 14  audio_naive:mfcc11:mean          4973 non-null   float64
 15  audio_naive:mfcc1:mean           4973 non-null   float64
 16  raw_magnet:magnitude_stats:mean  4973 non-null   float64
 17  audio_naive:mfcc7:mean           4973 non-null   float64
 18  raw_magnet:3d:mean_y             4973 non-null   float64
 19  raw_magnet:3d:mean_x             4973 non-null   float64
 20  audio_naive:mfcc2:mean           4973 non-null   float64
 21  audio_naive:mfcc12:mean          4973 non-null   float64
dtypes: float64(22)
memory usage: 893.6+ KB

C:\Users\XiaoBai\AppData\Local\Temp\ipykernel_11608\652685466.py:23: FutureWarning: Passing a set as an indexer is deprecated and will raise in a future version. Use a list instead.
  df = df.loc[:,feature]

Exploratory Data Analysis¶

In [17]:
import seaborn as sns  
sns.set_style('whitegrid')
In [18]:
with gzip.open('cleaned_data.zip','rb') as file:
    feature_data = pd.read_csv(file,index_col=[0,1])

with gzip.open('new_label_data.zip','rb') as file:
    new_label_data = pd.read_csv(file,index_col=[0,1])

data = pd.concat([feature_data,new_label_data],join='inner',ignore_index=False,axis=1)

Distribution of original label(bar plot)¶

In [19]:
import seaborn as sns

originLabel = np.zeros(shape = (1,51))
for uuid in data.groupby('uuid').count().index:
    X,Y,M,timestamps,feature_names,label_names = read_user_data(uuid)
    originLabel = np.concatenate((originLabel,Y),axis = 0)
np.delete(originLabel,1,axis=0)
x = np.arange(0,51)
y = originLabel.sum(axis = 0)
plt.bar(x,y)
plt.xlabel('labels (different number indicate different labels)')
plt.ylabel('number of data with the label')
Out[19]:
Text(0, 0.5, 'number of data with the label')

Heatmap of how many times label appear together¶

In [20]:
# this part used to show how many times two label both appear
temp = np.zeros((51,51))
s = originLabel.shape
# print(s)
for i in range(0,s[0]):
    arr = np.where(originLabel[i]==1)
    for i in range(0,len(arr[0])):
        temp[arr[0][i-1]][arr[0]] = temp[arr[0][i-1]][arr[0]] + 1
    
sns.heatmap(temp).invert_yaxis()

Labels that often appear together and never appear together¶

In [21]:
# shows the name of label which always exist together and never exist at the same time
indLabel = np.where(temp == 0)
label = np.where(temp>100000)
setLabel = set()
for i in label[0]:
    for j in label[1]:
        if i>=j:
            continue
        se = label_names[i]+' and '+label_names[j]
        setLabel.add(se)

indpend = set()
for i in indLabel[0]:
    for j in indLabel[1]:
        if i>=j:
            continue
        se = label_names[i]+' and '+label_names[j]
        indpend.add(se)
    
print(setLabel)
print(indpend)

{'OR_indoors and LOC_home', 'LOC_home and PHONE_ON_TABLE', 'OR_indoors and PHONE_ON_TABLE', 'SITTING and LOC_home', 'SITTING and OR_indoors', 'SITTING and PHONE_ON_TABLE'}
{'SURFING_THE_INTERNET and LOC_beach', 'STAIRS_-_GOING_UP and PHONE_IN_HAND', 'OR_exercise and WITH_FRIENDS', 'LYING_DOWN and FIX_restaurant', 'ON_A_BUS and PHONE_IN_POCKET', 'AT_A_BAR and AT_THE_GYM', 'SURFING_THE_INTERNET and PHONE_IN_HAND', 'DRIVE_-_I_M_THE_DRIVER and DRINKING__ALCOHOL_', 'SLEEPING and DRIVE_-_I_M_THE_DRIVER', 'OR_indoors and ELEVATOR', 'OR_outside and PHONE_IN_HAND', 'IN_CLASS and WITH_FRIENDS', 'WASHING_DISHES and DRESSING', 'LOC_main_workplace and COOKING', 'GROOMING and PHONE_IN_HAND', 'FIX_restaurant and COOKING', 'SHOPPING and SURFING_THE_INTERNET', 'FIX_walking and PHONE_IN_HAND', 'LAB_WORK and TALKING', 'DRIVE_-_I_M_THE_DRIVER and WATCHING_TV', 'OR_outside and FIX_restaurant', 'IN_CLASS and WATCHING_TV', 'OR_outside and PHONE_IN_BAG', 'LOC_main_workplace and AT_A_PARTY', 'LOC_main_workplace and DOING_LAUNDRY', 'LOC_main_workplace and OR_exercise', 'LAB_WORK and GROOMING', 'IN_CLASS and ON_A_BUS', 'STROLLING and LOC_beach', 'BATHING_-_SHOWER and TOILET', 'IN_A_MEETING and PHONE_IN_POCKET', 'IN_A_CAR and STROLLING', 'GROOMING and WITH_CO-WORKERS', 'CLEANING and DRESSING', 'TOILET and GROOMING', 'SHOPPING and STAIRS_-_GOING_DOWN', 'LYING_DOWN and BICYCLING', 'OR_indoors and TOILET', 'IN_CLASS and IN_A_MEETING', 'BICYCLING and TALKING', 'IN_A_MEETING and AT_A_PARTY', 'OR_outside and ON_A_BUS', 'LAB_WORK and OR_exercise', 'FIX_running and BICYCLING', 'COMPUTER_WORK and WITH_FRIENDS', 'ON_A_BUS and DRINKING__ALCOHOL_', 'STAIRS_-_GOING_DOWN and PHONE_ON_TABLE', 'FIX_running and PHONE_IN_BAG', 'SHOPPING and DRESSING', 'SINGING and TOILET', 'DRIVE_-_I_M_A_PASSENGER and WITH_CO-WORKERS', 'ON_A_BUS and AT_A_BAR', 'BATHING_-_SHOWER and WITH_FRIENDS', 'FIX_walking and LOC_beach', 'OR_exercise and AT_THE_GYM', 'IN_A_CAR and TOILET', 'SURFING_THE_INTERNET and EATING', 'SHOPPING and PHONE_IN_HAND', 'EATING and STAIRS_-_GOING_UP', 'FIX_walking and DRINKING__ALCOHOL_', 'FIX_running and SURFING_THE_INTERNET', 'SITTING and TOILET', 'GROOMING and AT_THE_GYM', 'DRINKING__ALCOHOL_ and LOC_beach', 'WASHING_DISHES and AT_A_BAR', 'DOING_LAUNDRY and PHONE_IN_BAG', 'WASHING_DISHES and COMPUTER_WORK', 'LOC_main_workplace and DRIVE_-_I_M_THE_DRIVER', 'BICYCLING and EATING', 'COOKING and AT_SCHOOL', 'FIX_running and EATING', 'WATCHING_TV and LOC_beach', 'FIX_walking and TALKING', 'PHONE_IN_POCKET and DRINKING__ALCOHOL_', 'FIX_running and CLEANING', 'SLEEPING and LAB_WORK', 'IN_A_MEETING and TALKING', 'LOC_home and GROOMING', 'STROLLING and GROOMING', 'ELEVATOR and AT_SCHOOL', 'IN_CLASS and COOKING', 'IN_A_CAR and SHOPPING', 'IN_A_CAR and OR_exercise', 'GROOMING and PHONE_ON_TABLE', 'IN_A_CAR and SINGING', 'STROLLING and COMPUTER_WORK', 'OR_indoors and DOING_LAUNDRY', 'DRINKING__ALCOHOL_ and AT_SCHOOL', 'SINGING and PHONE_IN_HAND', 'LOC_main_workplace and BATHING_-_SHOWER', 'OR_indoors and OR_standing', 'OR_outside and LOC_beach', 'IN_CLASS and LOC_main_workplace', 'TALKING and ELEVATOR', 'ON_A_BUS and CLEANING', 'FIX_running and OR_exercise', 'IN_A_MEETING and DRIVE_-_I_M_A_PASSENGER', 'LYING_DOWN and ELEVATOR', 'BATHING_-_SHOWER and WITH_CO-WORKERS', 'DRESSING and STAIRS_-_GOING_UP', 'BATHING_-_SHOWER and AT_A_PARTY', 'SITTING and TALKING', 'COOKING and WITH_FRIENDS', 'ON_A_BUS and GROOMING', 'STAIRS_-_GOING_DOWN and PHONE_IN_HAND', 'LAB_WORK and BATHING_-_SHOWER', 'FIX_walking and BICYCLING', 'LOC_home and PHONE_IN_BAG', 'AT_THE_GYM and PHONE_IN_HAND', 'OR_exercise and AT_A_BAR', 'LYING_DOWN and TOILET', 'SURFING_THE_INTERNET and OR_standing', 'OR_indoors and ON_A_BUS', 'GROOMING and STAIRS_-_GOING_DOWN', 'FIX_running and OR_outside', 'LOC_main_workplace and CLEANING', 'DRIVE_-_I_M_THE_DRIVER and AT_A_PARTY', 'OR_indoors and IN_A_CAR', 'OR_indoors and PHONE_ON_TABLE', 'IN_A_MEETING and WITH_FRIENDS', 'IN_A_CAR and WITH_FRIENDS', 'DOING_LAUNDRY and SURFING_THE_INTERNET', 'TALKING and EATING', 'EATING and WITH_CO-WORKERS', 'GROOMING and STAIRS_-_GOING_UP', 'IN_A_MEETING and STROLLING', 'BICYCLING and GROOMING', 'STROLLING and STAIRS_-_GOING_UP', 'FIX_running and FIX_restaurant', 'STAIRS_-_GOING_DOWN and WITH_FRIENDS', 'PHONE_IN_POCKET and SURFING_THE_INTERNET', 'DRIVE_-_I_M_THE_DRIVER and AT_THE_GYM', 'SURFING_THE_INTERNET and AT_A_BAR', 'SITTING and PHONE_IN_BAG', 'AT_THE_GYM and STAIRS_-_GOING_UP', 'PHONE_IN_HAND and WITH_FRIENDS', 'AT_A_PARTY and AT_THE_GYM', 'FIX_walking and AT_SCHOOL', 'OR_outside and WITH_CO-WORKERS', 'AT_A_PARTY and OR_standing', 'FIX_running and WATCHING_TV', 'IN_A_CAR and AT_THE_GYM', 'IN_A_CAR and COMPUTER_WORK', 'LAB_WORK and DRIVE_-_I_M_THE_DRIVER', 'STAIRS_-_GOING_DOWN and ELEVATOR', 'SINGING and TALKING', 'LOC_main_workplace and TALKING', 'AT_A_PARTY and LOC_beach', 'DOING_LAUNDRY and AT_A_BAR', 'LYING_DOWN and FIX_running', 'STAIRS_-_GOING_UP and WITH_CO-WORKERS', 'LOC_main_workplace and WASHING_DISHES', 'CLEANING and STAIRS_-_GOING_UP', 'IN_A_CAR and DOING_LAUNDRY', 'LYING_DOWN and WITH_FRIENDS', 'DRIVE_-_I_M_A_PASSENGER and LOC_home', 'PHONE_IN_POCKET and BATHING_-_SHOWER', 'COMPUTER_WORK and PHONE_ON_TABLE', 'BATHING_-_SHOWER and SURFING_THE_INTERNET', 'LOC_beach and SINGING', 'DRIVE_-_I_M_THE_DRIVER and COMPUTER_WORK', 'GROOMING and ELEVATOR', 'GROOMING and WITH_FRIENDS', 'LAB_WORK and DOING_LAUNDRY', 'SHOPPING and EATING', 'DRINKING__ALCOHOL_ and WASHING_DISHES', 'DRESSING and AT_THE_GYM', 'LOC_home and PHONE_ON_TABLE', 'COOKING and WITH_CO-WORKERS', 'EATING and PHONE_ON_TABLE', 'IN_A_CAR and EATING', 'FIX_walking and PHONE_ON_TABLE', 'OR_outside and STROLLING', 'ON_A_BUS and FIX_restaurant', 'CLEANING and AT_A_PARTY', 'LYING_DOWN and LAB_WORK', 'WASHING_DISHES and STAIRS_-_GOING_UP', 'LOC_main_workplace and WITH_CO-WORKERS', 'ON_A_BUS and STROLLING', 'OR_standing and PHONE_ON_TABLE', 'AT_A_PARTY and PHONE_IN_HAND', 'LOC_home and DOING_LAUNDRY', 'IN_A_MEETING and SHOPPING', 'WATCHING_TV and WITH_FRIENDS', 'OR_outside and STAIRS_-_GOING_UP', 'STAIRS_-_GOING_UP and AT_SCHOOL', 'IN_A_MEETING and OR_exercise', 'FIX_running and DRINKING__ALCOHOL_', 'FIX_running and GROOMING', 'STROLLING and DOING_LAUNDRY', 'CLEANING and STAIRS_-_GOING_DOWN', 'IN_A_CAR and ON_A_BUS', 'SLEEPING and ELEVATOR', 'LOC_main_workplace and OR_indoors', 'OR_exercise and PHONE_IN_BAG', 'TALKING and PHONE_IN_BAG', 'DRIVE_-_I_M_THE_DRIVER and PHONE_ON_TABLE', 'LAB_WORK and IN_A_MEETING', 'LOC_main_workplace and AT_THE_GYM', 'OR_indoors and AT_THE_GYM', 'SURFING_THE_INTERNET and AT_SCHOOL', 'WASHING_DISHES and TOILET', 'DOING_LAUNDRY and AT_A_PARTY', 'DRESSING and WITH_FRIENDS', 'FIX_walking and LOC_home', 'SITTING and PHONE_IN_HAND', 'CLEANING and WITH_CO-WORKERS', 'BATHING_-_SHOWER and SINGING', 'FIX_restaurant and WITH_CO-WORKERS', 'IN_A_MEETING and DRINKING__ALCOHOL_', 'COOKING and ELEVATOR', 'IN_CLASS and OR_outside', 'FIX_restaurant and AT_THE_GYM', 'DRIVE_-_I_M_A_PASSENGER and FIX_restaurant', 'FIX_restaurant and AT_A_BAR', 'LOC_beach and TOILET', 'ON_A_BUS and SURFING_THE_INTERNET', 'FIX_restaurant and OR_exercise', 'BICYCLING and DRIVE_-_I_M_THE_DRIVER', 'SLEEPING and LOC_beach', 'FIX_running and WITH_FRIENDS', 'IN_A_CAR and PHONE_IN_HAND', 'WASHING_DISHES and TALKING', 'COMPUTER_WORK and PHONE_IN_BAG', 'TALKING and PHONE_IN_HAND', 'AT_A_BAR and SINGING', 'OR_outside and WITH_FRIENDS', 'IN_A_MEETING and FIX_restaurant', 'LOC_home and STAIRS_-_GOING_DOWN', 'FIX_walking and BATHING_-_SHOWER', 'SITTING and SURFING_THE_INTERNET', 'EATING and WITH_FRIENDS', 'STAIRS_-_GOING_UP and WITH_FRIENDS', 'DRIVE_-_I_M_A_PASSENGER and DRINKING__ALCOHOL_', 'LAB_WORK and AT_A_BAR', 'CLEANING and SURFING_THE_INTERNET', 'PHONE_IN_POCKET and WITH_FRIENDS', 'FIX_running and STAIRS_-_GOING_UP', 'IN_CLASS and SHOPPING', 'LOC_home and STAIRS_-_GOING_UP', 'DRESSING and WITH_CO-WORKERS', 'SITTING and SLEEPING', 'LAB_WORK and WATCHING_TV', 'SITTING and IN_A_MEETING', 'OR_indoors and SURFING_THE_INTERNET', 'BATHING_-_SHOWER and AT_THE_GYM', 'SITTING and AT_A_BAR', 'AT_A_PARTY and WITH_CO-WORKERS', 'LOC_main_workplace and PHONE_ON_TABLE', 'IN_A_CAR and PHONE_ON_TABLE', 'OR_outside and AT_SCHOOL', 'LYING_DOWN and OR_standing', 'ON_A_BUS and TOILET', 'TOILET and PHONE_IN_HAND', 'SURFING_THE_INTERNET and ELEVATOR', 'BICYCLING and AT_A_BAR', 'OR_indoors and DRIVE_-_I_M_THE_DRIVER', 'SITTING and SHOPPING', 'PHONE_IN_POCKET and PHONE_IN_BAG', 'COOKING and STAIRS_-_GOING_DOWN', 'OR_indoors and PHONE_IN_BAG', 'CLEANING and WASHING_DISHES', 'LYING_DOWN and FIX_walking', 'IN_A_MEETING and CLEANING', 'DRIVE_-_I_M_THE_DRIVER and STROLLING', 'SHOPPING and DRINKING__ALCOHOL_', 'LYING_DOWN and WASHING_DISHES', 'ON_A_BUS and OR_standing', 'WATCHING_TV and EATING', 'DRIVE_-_I_M_THE_DRIVER and PHONE_IN_POCKET', 'STROLLING and AT_SCHOOL', 'DRIVE_-_I_M_THE_DRIVER and CLEANING', 'DRIVE_-_I_M_THE_DRIVER and COOKING', 'SLEEPING and BATHING_-_SHOWER', 'FIX_running and LOC_home', 'DRIVE_-_I_M_A_PASSENGER and EATING', 'LYING_DOWN and DOING_LAUNDRY', 'FIX_restaurant and SHOPPING', 'BICYCLING and DOING_LAUNDRY', 'FIX_running and SINGING', 'LYING_DOWN and STROLLING', 'BATHING_-_SHOWER and PHONE_ON_TABLE', 'IN_CLASS and PHONE_IN_BAG', 'OR_indoors and PHONE_IN_POCKET', 'SLEEPING and GROOMING', 'DRINKING__ALCOHOL_ and DRESSING', 'WATCHING_TV and PHONE_ON_TABLE', 'OR_exercise and SHOPPING', 'DRINKING__ALCOHOL_ and STAIRS_-_GOING_DOWN', 'IN_CLASS and PHONE_IN_POCKET', 'IN_CLASS and IN_A_CAR', 'LAB_WORK and FIX_restaurant', 'WATCHING_TV and COMPUTER_WORK', 'LYING_DOWN and AT_A_BAR', 'IN_A_MEETING and PHONE_IN_HAND', 'TALKING and OR_standing', 'OR_indoors and SHOPPING', 'STAIRS_-_GOING_UP and STAIRS_-_GOING_DOWN', 'PHONE_IN_POCKET and ELEVATOR', 'WATCHING_TV and GROOMING', 'SLEEPING and WASHING_DISHES', 'AT_A_BAR and DRESSING', 'SITTING and DRIVE_-_I_M_A_PASSENGER', 'SLEEPING and OR_outside', 'OR_indoors and LOC_beach', 'CLEANING and GROOMING', 'DRIVE_-_I_M_THE_DRIVER and TALKING', 'SITTING and DRIVE_-_I_M_THE_DRIVER', 'BICYCLING and DRIVE_-_I_M_A_PASSENGER', 'DOING_LAUNDRY and WATCHING_TV', 'PHONE_ON_TABLE and WITH_FRIENDS', 'COOKING and OR_standing', 'ON_A_BUS and ELEVATOR', 'LAB_WORK and SINGING', 'OR_standing and AT_SCHOOL', 'DRIVE_-_I_M_THE_DRIVER and SURFING_THE_INTERNET', 'OR_indoors and PHONE_IN_HAND', 'SITTING and SINGING', 'DRIVE_-_I_M_A_PASSENGER and DRESSING', 'LYING_DOWN and AT_SCHOOL', 'FIX_restaurant and TOILET', 'SHOPPING and TALKING', 'OR_indoors and DRINKING__ALCOHOL_', 'FIX_walking and OR_exercise', 'SINGING and AT_THE_GYM', 'BICYCLING and SURFING_THE_INTERNET', 'LOC_main_workplace and AT_SCHOOL', 'OR_indoors and COMPUTER_WORK', 'FIX_running and OR_indoors', 'BATHING_-_SHOWER and AT_A_BAR', 'FIX_restaurant and ELEVATOR', 'FIX_running and PHONE_ON_TABLE', 'AT_SCHOOL and WITH_FRIENDS', 'FIX_running and TOILET', 'AT_A_PARTY and PHONE_ON_TABLE', 'COMPUTER_WORK and GROOMING', 'FIX_restaurant and WITH_FRIENDS', 'WATCHING_TV and STAIRS_-_GOING_DOWN', 'AT_A_BAR and PHONE_IN_HAND', 'LAB_WORK and AT_A_PARTY', 'LOC_beach and STAIRS_-_GOING_UP', 'COOKING and TOILET', 'FIX_walking and PHONE_IN_POCKET', 'STROLLING and STAIRS_-_GOING_DOWN', 'OR_exercise and PHONE_IN_HAND', 'LYING_DOWN and LOC_beach', 'DRINKING__ALCOHOL_ and GROOMING', 'BICYCLING and DRESSING', 'DRINKING__ALCOHOL_ and OR_standing', 'SHOPPING and SINGING', 'FIX_walking and WATCHING_TV', 'IN_A_MEETING and WITH_CO-WORKERS', 'OR_exercise and COMPUTER_WORK', 'OR_indoors and LOC_home', 'BICYCLING and STAIRS_-_GOING_DOWN', 'CLEANING and PHONE_IN_BAG', 'FIX_walking and SINGING', 'ELEVATOR and PHONE_IN_HAND', 'IN_A_MEETING and COOKING', 'PHONE_IN_POCKET and EATING', 'WATCHING_TV and AT_A_BAR', 'SITTING and IN_CLASS', 'STROLLING and AT_A_BAR', 'DRINKING__ALCOHOL_ and DOING_LAUNDRY', 'SURFING_THE_INTERNET and PHONE_ON_TABLE', 'FIX_walking and IN_A_MEETING', 'OR_outside and SURFING_THE_INTERNET', 'STROLLING and SINGING', 'OR_exercise and SINGING', 'FIX_walking and FIX_restaurant', 'DRIVE_-_I_M_A_PASSENGER and CLEANING', 'AT_A_PARTY and COMPUTER_WORK', 'IN_CLASS and STROLLING', 'IN_CLASS and ELEVATOR', 'SITTING and LOC_home', 'FIX_walking and FIX_running', 'FIX_running and DRIVE_-_I_M_THE_DRIVER', 'SINGING and EATING', 'OR_exercise and TOILET', 'DRIVE_-_I_M_THE_DRIVER and DRESSING', 'EATING and PHONE_IN_BAG', 'LAB_WORK and WITH_FRIENDS', 'LOC_main_workplace and IN_A_CAR', 'DRIVE_-_I_M_THE_DRIVER and EATING', 'DRIVE_-_I_M_THE_DRIVER and ELEVATOR', 'BICYCLING and LOC_home', 'STROLLING and AT_A_PARTY', 'CLEANING and AT_A_BAR', 'WASHING_DISHES and PHONE_IN_BAG', 'WATCHING_TV and ELEVATOR', 'FIX_running and ELEVATOR', 'IN_A_MEETING and DRIVE_-_I_M_THE_DRIVER', 'IN_A_MEETING and SINGING', 'LOC_main_workplace and TOILET', 'WASHING_DISHES and OR_standing', 'LOC_home and SURFING_THE_INTERNET', 'GROOMING and OR_standing', 'OR_outside and WASHING_DISHES', 'OR_indoors and WITH_CO-WORKERS', 'LOC_main_workplace and EATING', 'LOC_home and WASHING_DISHES', 'ON_A_BUS and WITH_CO-WORKERS', 'DRINKING__ALCOHOL_ and WATCHING_TV', 'SHOPPING and STROLLING', 'FIX_running and STROLLING', 'FIX_walking and OR_outside', 'IN_CLASS and COMPUTER_WORK', 'OR_exercise and WATCHING_TV', 'LAB_WORK and IN_A_CAR', 'FIX_walking and COMPUTER_WORK', 'SLEEPING and AT_A_BAR', 'DRIVE_-_I_M_A_PASSENGER and STAIRS_-_GOING_UP', 'STROLLING and WITH_CO-WORKERS', 'SITTING and IN_A_CAR', 'CLEANING and DOING_LAUNDRY', 'LYING_DOWN and SINGING', 'PHONE_IN_POCKET and WITH_CO-WORKERS', 'BICYCLING and WITH_CO-WORKERS', 'DRIVE_-_I_M_A_PASSENGER and AT_SCHOOL', 'DRIVE_-_I_M_A_PASSENGER and OR_standing', 'DRIVE_-_I_M_A_PASSENGER and PHONE_IN_POCKET', 'COOKING and CLEANING', 'PHONE_IN_POCKET and COMPUTER_WORK', 'IN_CLASS and OR_standing', 'SITTING and LAB_WORK', 'STAIRS_-_GOING_DOWN and OR_standing', 'SLEEPING and LOC_main_workplace', 'DRINKING__ALCOHOL_ and PHONE_IN_HAND', 'AT_THE_GYM and WITH_FRIENDS', 'LAB_WORK and PHONE_IN_BAG', 'DRIVE_-_I_M_A_PASSENGER and WATCHING_TV', 'SLEEPING and IN_A_CAR', 'DRIVE_-_I_M_A_PASSENGER and LOC_beach', 'ON_A_BUS and DRIVE_-_I_M_THE_DRIVER', 'LOC_beach and PHONE_IN_BAG', 'LOC_main_workplace and LOC_home', 'SLEEPING and STAIRS_-_GOING_DOWN', 'DRINKING__ALCOHOL_ and SURFING_THE_INTERNET', 'OR_outside and DRIVE_-_I_M_A_PASSENGER', 'DRIVE_-_I_M_THE_DRIVER and PHONE_IN_BAG', 'AT_A_BAR and TOILET', 'DRINKING__ALCOHOL_ and EATING', 'WASHING_DISHES and PHONE_IN_HAND', 'SLEEPING and DRIVE_-_I_M_A_PASSENGER', 'DRIVE_-_I_M_A_PASSENGER and ELEVATOR', 'SHOPPING and OR_standing', 'OR_outside and TOILET', 'FIX_running and TALKING', 'DRINKING__ALCOHOL_ and AT_THE_GYM', 'FIX_running and DOING_LAUNDRY', 'FIX_running and IN_CLASS', 'SINGING and ELEVATOR', 'FIX_walking and STROLLING', 'LYING_DOWN and IN_A_CAR', 'LOC_main_workplace and SHOPPING', 'DRIVE_-_I_M_THE_DRIVER and AT_A_BAR', 'OR_outside and AT_A_BAR', 'FIX_running and COOKING', 'OR_outside and COMPUTER_WORK', 'SHOPPING and TOILET', 'IN_A_MEETING and COMPUTER_WORK', 'BATHING_-_SHOWER and DOING_LAUNDRY', 'IN_CLASS and TOILET', 'DRIVE_-_I_M_A_PASSENGER and SINGING', 'IN_A_MEETING and ELEVATOR', 'IN_A_MEETING and WATCHING_TV', 'SURFING_THE_INTERNET and WITH_FRIENDS', 'GROOMING and DRESSING', 'DOING_LAUNDRY and AT_SCHOOL', 'FIX_restaurant and SINGING', 'IN_A_MEETING and LOC_beach', 'SITTING and ELEVATOR', 'BICYCLING and SHOPPING', 'COMPUTER_WORK and WITH_CO-WORKERS', 'LOC_beach and AT_SCHOOL', 'LYING_DOWN and WITH_CO-WORKERS', 'BICYCLING and OR_outside', 'OR_exercise and AT_SCHOOL', 'TALKING and STAIRS_-_GOING_DOWN', 'OR_outside and DRINKING__ALCOHOL_', 'STROLLING and PHONE_IN_HAND', 'LAB_WORK and PHONE_IN_POCKET', 'WASHING_DISHES and ELEVATOR', 'IN_A_CAR and DRIVE_-_I_M_THE_DRIVER', 'ON_A_BUS and TALKING', 'TALKING and WITH_FRIENDS', 'SITTING and FIX_running', 'OR_outside and BATHING_-_SHOWER', 'AT_THE_GYM and AT_SCHOOL', 'ON_A_BUS and PHONE_ON_TABLE', 'DRIVE_-_I_M_THE_DRIVER and WITH_CO-WORKERS', 'LOC_beach and DRESSING', 'WASHING_DISHES and STAIRS_-_GOING_DOWN', 'SITTING and WATCHING_TV', 'STROLLING and TOILET', 'FIX_walking and ON_A_BUS', 'AT_THE_GYM and OR_standing', 'FIX_restaurant and SURFING_THE_INTERNET', 'FIX_running and PHONE_IN_HAND', 'IN_CLASS and AT_THE_GYM', 'OR_outside and OR_exercise', 'OR_indoors and AT_SCHOOL', 'OR_indoors and FIX_restaurant', 'PHONE_IN_POCKET and SINGING', 'LAB_WORK and ON_A_BUS', 'OR_exercise and WASHING_DISHES', 'WASHING_DISHES and AT_SCHOOL', 'SINGING and COMPUTER_WORK', 'SURFING_THE_INTERNET and TALKING', 'BICYCLING and TOILET', 'LAB_WORK and COOKING', 'DRIVE_-_I_M_THE_DRIVER and WITH_FRIENDS', 'FIX_restaurant and AT_SCHOOL', 'WATCHING_TV and DRESSING', 'SINGING and STAIRS_-_GOING_UP', 'LOC_beach and STAIRS_-_GOING_DOWN', 'SITTING and ON_A_BUS', 'LYING_DOWN and LOC_home', 'PHONE_IN_POCKET and OR_exercise', 'IN_A_MEETING and DRESSING', 'COOKING and SINGING', 'SLEEPING and PHONE_IN_POCKET', 'LOC_home and AT_A_BAR', 'SHOPPING and AT_A_PARTY', 'DRIVE_-_I_M_A_PASSENGER and WASHING_DISHES', 'ON_A_BUS and LOC_beach', 'SURFING_THE_INTERNET and COMPUTER_WORK', 'WATCHING_TV and STAIRS_-_GOING_UP', 'SINGING and DRESSING', 'FIX_walking and STAIRS_-_GOING_UP', 'DOING_LAUNDRY and OR_standing', 'AT_SCHOOL and WITH_CO-WORKERS', 'COOKING and DOING_LAUNDRY', 'BATHING_-_SHOWER and PHONE_IN_HAND', 'LOC_main_workplace and OR_standing', 'EATING and OR_standing', 'LYING_DOWN and LOC_main_workplace', 'AT_A_PARTY and STAIRS_-_GOING_DOWN', 'BICYCLING and SINGING', 'LOC_main_workplace and SINGING', 'LOC_home and PHONE_IN_HAND', 'SITTING and DRESSING', 'CLEANING and AT_SCHOOL', 'AT_A_BAR and OR_standing', 'SLEEPING and TALKING', 'IN_A_MEETING and LOC_home', 'TOILET and AT_SCHOOL', 'ON_A_BUS and DRIVE_-_I_M_A_PASSENGER', 'LOC_home and EATING', 'LYING_DOWN and SITTING', 'LAB_WORK and STAIRS_-_GOING_DOWN', 'PHONE_IN_HAND and WITH_CO-WORKERS', 'OR_outside and WATCHING_TV', 'DRIVE_-_I_M_A_PASSENGER and WITH_FRIENDS', 'COMPUTER_WORK and EATING', 'DOING_LAUNDRY and COMPUTER_WORK', 'IN_A_CAR and TALKING', 'IN_CLASS and OR_indoors', 'SLEEPING and AT_SCHOOL', 'COOKING and DRINKING__ALCOHOL_', 'WASHING_DISHES and AT_THE_GYM', 'ON_A_BUS and AT_SCHOOL', 'IN_A_CAR and LOC_home', 'LAB_WORK and ELEVATOR', 'LYING_DOWN and DRIVE_-_I_M_A_PASSENGER', 'IN_A_CAR and DRESSING', 'AT_A_BAR and PHONE_IN_BAG', 'PHONE_IN_POCKET and AT_SCHOOL', 'AT_A_BAR and PHONE_ON_TABLE', 'STAIRS_-_GOING_UP and PHONE_ON_TABLE', 'PHONE_IN_BAG and PHONE_ON_TABLE', 'FIX_restaurant and STAIRS_-_GOING_DOWN', 'IN_A_MEETING and LOC_main_workplace', 'OR_outside and DRIVE_-_I_M_THE_DRIVER', 'WASHING_DISHES and SURFING_THE_INTERNET', 'FIX_walking and SHOPPING', 'SHOPPING and GROOMING', 'LYING_DOWN and ON_A_BUS', 'WASHING_DISHES and AT_A_PARTY', 'STROLLING and WATCHING_TV', 'OR_outside and DRESSING', 'SINGING and OR_standing', 'LOC_main_workplace and ON_A_BUS', 'FIX_walking and PHONE_IN_BAG', 'OR_exercise and LOC_beach', 'TOILET and AT_THE_GYM', 'FIX_restaurant and BATHING_-_SHOWER', 'AT_A_BAR and ELEVATOR', 'ELEVATOR and OR_standing', 'FIX_walking and COOKING', 'IN_A_MEETING and STAIRS_-_GOING_UP', 'OR_indoors and COOKING', 'SITTING and STAIRS_-_GOING_UP', 'AT_A_PARTY and DRESSING', 'FIX_running and IN_A_CAR', 'IN_A_CAR and BATHING_-_SHOWER', 'CLEANING and COMPUTER_WORK', 'SLEEPING and COOKING', 'GROOMING and PHONE_IN_BAG', 'LOC_home and FIX_restaurant', 'PHONE_IN_POCKET and STAIRS_-_GOING_UP', 'AT_A_BAR and GROOMING', 'FIX_walking and DRESSING', 'STROLLING and EATING', 'FIX_running and LOC_main_workplace', 'SLEEPING and STAIRS_-_GOING_UP', 'IN_CLASS and WASHING_DISHES', 'BICYCLING and ELEVATOR', 'FIX_walking and WASHING_DISHES', 'OR_exercise and DRINKING__ALCOHOL_', 'AT_A_PARTY and AT_SCHOOL', 'IN_A_MEETING and GROOMING', 'AT_A_BAR and LOC_beach', 'IN_A_MEETING and ON_A_BUS', 'DRIVE_-_I_M_A_PASSENGER and OR_exercise', 'OR_outside and AT_THE_GYM', 'LAB_WORK and SURFING_THE_INTERNET', 'BATHING_-_SHOWER and CLEANING', 'FIX_restaurant and DRINKING__ALCOHOL_', 'DRINKING__ALCOHOL_ and AT_A_PARTY', 'TOILET and STAIRS_-_GOING_UP', 'LOC_home and AT_THE_GYM', 'OR_exercise and SURFING_THE_INTERNET', 'LOC_home and TOILET', 'COOKING and PHONE_IN_BAG', 'DOING_LAUNDRY and WASHING_DISHES', 'AT_A_PARTY and WITH_FRIENDS', 'OR_outside and OR_standing', 'SLEEPING and PHONE_IN_HAND', 'STROLLING and PHONE_ON_TABLE', 'FIX_walking and TOILET', 'IN_A_CAR and DRIVE_-_I_M_A_PASSENGER', 'SITTING and LOC_beach', 'LOC_main_workplace and LOC_beach', 'PHONE_ON_TABLE and WITH_CO-WORKERS', 'LAB_WORK and EATING', 'IN_A_CAR and OR_standing', 'SLEEPING and TOILET', 'IN_CLASS and SINGING', 'LOC_home and WITH_CO-WORKERS', 'BICYCLING and LAB_WORK', 'LOC_main_workplace and AT_A_BAR', 'OR_exercise and COOKING', 'LYING_DOWN and DRIVE_-_I_M_THE_DRIVER', 'TOILET and WITH_CO-WORKERS', 'COOKING and SHOPPING', 'CLEANING and WITH_FRIENDS', 'FIX_restaurant and PHONE_ON_TABLE', 'DRIVE_-_I_M_THE_DRIVER and STAIRS_-_GOING_UP', 'LOC_home and STROLLING', 'BICYCLING and IN_A_MEETING', 'LYING_DOWN and CLEANING', 'SLEEPING and CLEANING', 'ON_A_BUS and COOKING', 'LAB_WORK and OR_indoors', 'BICYCLING and AT_SCHOOL', 'FIX_running and ON_A_BUS', 'AT_A_PARTY and TOILET', 'COOKING and COMPUTER_WORK', 'LOC_home and COMPUTER_WORK', 'LOC_main_workplace and WITH_FRIENDS', 'CLEANING and LOC_beach', 'SLEEPING and WITH_FRIENDS', 'IN_CLASS and TALKING', 'LYING_DOWN and IN_CLASS', 'IN_A_MEETING and OR_standing', 'WITH_CO-WORKERS and WITH_FRIENDS', 'FIX_running and STAIRS_-_GOING_DOWN', 'TALKING and TOILET', 'SITTING and WITH_FRIENDS', 'BICYCLING and FIX_restaurant', 'DRINKING__ALCOHOL_ and TALKING', 'LOC_beach and PHONE_IN_HAND', 'IN_CLASS and GROOMING', 'ON_A_BUS and PHONE_IN_HAND', 'FIX_running and WASHING_DISHES', 'STAIRS_-_GOING_UP and PHONE_IN_BAG', 'FIX_running and AT_THE_GYM', 'LOC_home and TALKING', 'COOKING and DRESSING', 'LYING_DOWN and COOKING', 'STROLLING and CLEANING', 'LOC_beach and WITH_CO-WORKERS', 'LOC_home and SHOPPING', 'LAB_WORK and COMPUTER_WORK', 'COOKING and PHONE_ON_TABLE', 'OR_outside and STAIRS_-_GOING_DOWN', 'PHONE_IN_POCKET and CLEANING', 'OR_standing and WITH_CO-WORKERS', 'COMPUTER_WORK and ELEVATOR', 'SLEEPING and FIX_restaurant', 'LAB_WORK and WASHING_DISHES', 'COOKING and BATHING_-_SHOWER', 'DOING_LAUNDRY and STAIRS_-_GOING_UP', 'IN_A_CAR and AT_A_BAR', 'OR_indoors and STAIRS_-_GOING_UP', 'FIX_walking and IN_CLASS', 'FIX_walking and AT_A_PARTY', 'LYING_DOWN and OR_indoors', 'FIX_restaurant and DOING_LAUNDRY', 'PHONE_IN_POCKET and OR_standing', 'DRESSING and OR_standing', 'STROLLING and DRESSING', 'EATING and STAIRS_-_GOING_DOWN', 'FIX_running and LAB_WORK', 'SLEEPING and AT_A_PARTY', 'BICYCLING and DRINKING__ALCOHOL_', 'WATCHING_TV and AT_THE_GYM', 'SINGING and GROOMING', 'BICYCLING and WASHING_DISHES', 'LYING_DOWN and AT_A_PARTY', 'CLEANING and SINGING', 'DRIVE_-_I_M_A_PASSENGER and TALKING', 'DRESSING and STAIRS_-_GOING_DOWN', 'LOC_home and WITH_FRIENDS', 'CLEANING and PHONE_ON_TABLE', 'STROLLING and ELEVATOR', 'BICYCLING and OR_indoors', 'DOING_LAUNDRY and AT_THE_GYM', 'LYING_DOWN and AT_THE_GYM', 'DOING_LAUNDRY and PHONE_IN_HAND', 'FIX_walking and STAIRS_-_GOING_DOWN', 'PHONE_IN_POCKET and STAIRS_-_GOING_DOWN', 'SLEEPING and SINGING', 'FIX_walking and LAB_WORK', 'DRIVE_-_I_M_THE_DRIVER and OR_exercise', 'OR_outside and PHONE_ON_TABLE', 'SITTING and OR_outside', 'FIX_running and AT_SCHOOL', 'LOC_home and AT_SCHOOL', 'SITTING and PHONE_ON_TABLE', 'LOC_beach and GROOMING', 'BICYCLING and WATCHING_TV', 'IN_CLASS and AT_A_BAR', 'SITTING and COMPUTER_WORK', 'SURFING_THE_INTERNET and TOILET', 'OR_outside and IN_A_CAR', 'CLEANING and OR_standing', 'BATHING_-_SHOWER and OR_standing', 'IN_CLASS and DRIVE_-_I_M_A_PASSENGER', 'FIX_walking and CLEANING', 'SLEEPING and DRESSING', 'SLEEPING and STROLLING', 'SURFING_THE_INTERNET and GROOMING', 'LYING_DOWN and SHOPPING', 'SLEEPING and DRINKING__ALCOHOL_', 'LOC_main_workplace and ELEVATOR', 'FIX_running and SHOPPING', 'WASHING_DISHES and WATCHING_TV', 'IN_A_CAR and AT_A_PARTY', 'SITTING and FIX_restaurant', 'DRIVE_-_I_M_THE_DRIVER and AT_SCHOOL', 'BATHING_-_SHOWER and EATING', 'LOC_main_workplace and DRINKING__ALCOHOL_', 'COOKING and EATING', 'AT_A_BAR and WITH_FRIENDS', 'STROLLING and TALKING', 'FIX_running and COMPUTER_WORK', 'FIX_restaurant and OR_standing', 'SITTING and BATHING_-_SHOWER', 'SLEEPING and IN_CLASS', 'ON_A_BUS and AT_THE_GYM', 'IN_CLASS and WITH_CO-WORKERS', 'OR_indoors and STAIRS_-_GOING_DOWN', 'LAB_WORK and IN_CLASS', 'OR_outside and LOC_home', 'TOILET and OR_standing', 'WATCHING_TV and WITH_CO-WORKERS', 'IN_A_CAR and COOKING', 'AT_A_BAR and EATING', 'IN_A_MEETING and OR_outside', 'SITTING and COOKING', 'LOC_main_workplace and GROOMING', 'BICYCLING and PHONE_IN_POCKET', 'OR_indoors and GROOMING', 'SHOPPING and WATCHING_TV', 'OR_indoors and AT_A_PARTY', 'CLEANING and ELEVATOR', 'AT_A_BAR and TALKING', 'FIX_walking and EATING', 'DOING_LAUNDRY and EATING', 'IN_A_CAR and WATCHING_TV', 'SHOPPING and WASHING_DISHES', 'SITTING and WITH_CO-WORKERS', 'IN_CLASS and DOING_LAUNDRY', 'STROLLING and WASHING_DISHES', 'COMPUTER_WORK and DRESSING', 'IN_A_CAR and AT_SCHOOL', 'SHOPPING and BATHING_-_SHOWER', 'CLEANING and PHONE_IN_HAND', 'SINGING and WITH_FRIENDS', 'FIX_restaurant and AT_A_PARTY', 'LYING_DOWN and OR_exercise', 'OR_exercise and EATING', 'FIX_walking and IN_A_CAR', 'DRIVE_-_I_M_A_PASSENGER and STROLLING', 'IN_A_CAR and SURFING_THE_INTERNET', 'DRINKING__ALCOHOL_ and BATHING_-_SHOWER', 'LYING_DOWN and DRESSING', 'OR_exercise and TALKING', 'IN_A_CAR and GROOMING', 'SITTING and PHONE_IN_POCKET', 'OR_exercise and ELEVATOR', 'WATCHING_TV and OR_standing', 'PHONE_IN_POCKET and WASHING_DISHES', 'PHONE_IN_POCKET and SHOPPING', 'OR_standing and PHONE_IN_HAND', 'WASHING_DISHES and EATING', 'SHOPPING and ELEVATOR', 'FIX_walking and SURFING_THE_INTERNET', 'ELEVATOR and WITH_CO-WORKERS', 'COOKING and LOC_beach', 'OR_indoors and OR_exercise', 'DRIVE_-_I_M_A_PASSENGER and GROOMING', 'EATING and AT_THE_GYM', 'BICYCLING and SLEEPING', 'LOC_main_workplace and WATCHING_TV', 'PHONE_IN_POCKET and GROOMING', 'LOC_main_workplace and STAIRS_-_GOING_DOWN', 'LOC_home and DRINKING__ALCOHOL_', 'COOKING and SURFING_THE_INTERNET', 'DRIVE_-_I_M_A_PASSENGER and PHONE_IN_BAG', 'FIX_restaurant and PHONE_IN_BAG', 'TOILET and DRESSING', 'ON_A_BUS and SINGING', 'IN_CLASS and LOC_beach', 'LYING_DOWN and EATING', 'IN_CLASS and AT_A_PARTY', 'PHONE_IN_POCKET and TALKING', 'SITTING and STAIRS_-_GOING_DOWN', 'BICYCLING and STAIRS_-_GOING_UP', 'ON_A_BUS and WASHING_DISHES', 'LYING_DOWN and DRINKING__ALCOHOL_', 'LOC_home and OR_standing', 'WASHING_DISHES and SINGING', 'DRIVE_-_I_M_A_PASSENGER and PHONE_ON_TABLE', 'IN_A_MEETING and AT_A_BAR', 'IN_CLASS and DRESSING', 'SLEEPING and OR_exercise', 'CLEANING and TOILET', 'ON_A_BUS and DRESSING', 'DRIVE_-_I_M_A_PASSENGER and AT_A_PARTY', 'TALKING and AT_SCHOOL', 'AT_A_PARTY and ELEVATOR', 'PHONE_IN_POCKET and DOING_LAUNDRY', 'LYING_DOWN and WATCHING_TV', 'LOC_beach and OR_standing', 'LOC_main_workplace and COMPUTER_WORK', 'ON_A_BUS and STAIRS_-_GOING_UP', 'AT_SCHOOL and PHONE_ON_TABLE', 'LOC_home and WATCHING_TV', 'SURFING_THE_INTERNET and STAIRS_-_GOING_UP', 'LYING_DOWN and PHONE_IN_POCKET', 'WASHING_DISHES and PHONE_ON_TABLE', 'LOC_main_workplace and STAIRS_-_GOING_UP', 'BATHING_-_SHOWER and PHONE_IN_BAG', 'DRINKING__ALCOHOL_ and PHONE_IN_BAG', 'SHOPPING and AT_SCHOOL', 'AT_A_BAR and AT_SCHOOL', 'IN_CLASS and LOC_home', 'IN_CLASS and PHONE_ON_TABLE', 'LOC_beach and TALKING', 'PHONE_IN_POCKET and DRESSING', 'OR_exercise and DOING_LAUNDRY', 'TALKING and AT_THE_GYM', 'BATHING_-_SHOWER and GROOMING', 'STROLLING and OR_standing', 'STROLLING and WITH_FRIENDS', 'LOC_home and SINGING', 'IN_A_CAR and PHONE_IN_POCKET', 'SITTING and CLEANING', 'PHONE_IN_POCKET and COOKING', 'SLEEPING and PHONE_IN_BAG', 'DRIVE_-_I_M_THE_DRIVER and TOILET', 'SHOPPING and LOC_beach', 'DRIVE_-_I_M_THE_DRIVER and PHONE_IN_HAND', 'FIX_restaurant and WATCHING_TV', 'ELEVATOR and WITH_FRIENDS', 'ON_A_BUS and SHOPPING', 'FIX_restaurant and LOC_beach', 'BICYCLING and COOKING', 'PHONE_IN_POCKET and AT_THE_GYM', 'LAB_WORK and LOC_home', 'BICYCLING and BATHING_-_SHOWER', 'SLEEPING and DOING_LAUNDRY', 'PHONE_IN_BAG and WITH_CO-WORKERS', 'SHOPPING and COMPUTER_WORK', 'LYING_DOWN and COMPUTER_WORK', 'OR_indoors and WITH_FRIENDS', 'BATHING_-_SHOWER and WASHING_DISHES', 'FIX_running and BATHING_-_SHOWER', 'BATHING_-_SHOWER and DRESSING', 'LOC_main_workplace and FIX_restaurant', 'PHONE_IN_HAND and PHONE_ON_TABLE', 'FIX_walking and DRIVE_-_I_M_A_PASSENGER', 'LOC_home and COOKING', 'ON_A_BUS and BATHING_-_SHOWER', 'DRIVE_-_I_M_A_PASSENGER and COOKING', 'DOING_LAUNDRY and ELEVATOR', 'TOILET and WITH_FRIENDS', 'OR_indoors and DRESSING', 'FIX_walking and GROOMING', 'SURFING_THE_INTERNET and STAIRS_-_GOING_DOWN', 'IN_CLASS and CLEANING', 'COMPUTER_WORK and TOILET', 'LAB_WORK and WITH_CO-WORKERS', 'AT_SCHOOL and PHONE_IN_BAG', 'WASHING_DISHES and WITH_FRIENDS', 'DOING_LAUNDRY and TALKING', 'DRESSING and AT_SCHOOL', 'IN_A_CAR and LOC_beach', 'SITTING and WASHING_DISHES', 'LYING_DOWN and SLEEPING', 'LAB_WORK and PHONE_ON_TABLE', 'BATHING_-_SHOWER and STAIRS_-_GOING_UP', 'DRINKING__ALCOHOL_ and STAIRS_-_GOING_UP', 'OR_indoors and EATING', 'AT_THE_GYM and STAIRS_-_GOING_DOWN', 'ELEVATOR and PHONE_IN_BAG', 'SHOPPING and AT_THE_GYM', 'IN_A_MEETING and DOING_LAUNDRY', 'BATHING_-_SHOWER and ELEVATOR', 'FIX_walking and AT_A_BAR', 'WATCHING_TV and PHONE_IN_HAND', 'DRIVE_-_I_M_THE_DRIVER and LOC_home', 'DRIVE_-_I_M_THE_DRIVER and BATHING_-_SHOWER', 'STROLLING and DRINKING__ALCOHOL_', 'LAB_WORK and STROLLING', 'LOC_beach and COMPUTER_WORK', 'LAB_WORK and OR_outside', 'EATING and GROOMING', 'CLEANING and AT_THE_GYM', 'PHONE_IN_HAND and PHONE_IN_BAG', 'DRIVE_-_I_M_THE_DRIVER and LOC_beach', 'SLEEPING and SURFING_THE_INTERNET', 'DRIVE_-_I_M_THE_DRIVER and WASHING_DISHES', 'IN_A_CAR and FIX_restaurant', 'IN_A_MEETING and PHONE_IN_BAG', 'FIX_restaurant and DRESSING', 'STROLLING and BATHING_-_SHOWER', 'LOC_home and PHONE_IN_POCKET', 'FIX_restaurant and WASHING_DISHES', 'AT_A_PARTY and PHONE_IN_BAG', 'COOKING and GROOMING', 'BICYCLING and AT_A_PARTY', 'TALKING and DRESSING', 'PHONE_IN_POCKET and AT_A_BAR', 'WATCHING_TV and TOILET', 'SITTING and AT_A_PARTY', 'EATING and AT_SCHOOL', 'ON_A_BUS and WATCHING_TV', 'FIX_walking and WITH_FRIENDS', 'DRINKING__ALCOHOL_ and COMPUTER_WORK', 'DOING_LAUNDRY and WITH_FRIENDS', 'WASHING_DISHES and GROOMING', 'FIX_walking and DRIVE_-_I_M_THE_DRIVER', 'LAB_WORK and TOILET', 'ON_A_BUS and COMPUTER_WORK', 'LOC_beach and EATING', 'IN_A_MEETING and EATING', 'PHONE_IN_POCKET and TOILET', 'OR_outside and CLEANING', 'LAB_WORK and PHONE_IN_HAND', 'ON_A_BUS and DOING_LAUNDRY', 'ON_A_BUS and STAIRS_-_GOING_DOWN', 'SURFING_THE_INTERNET and AT_THE_GYM', 'IN_A_MEETING and TOILET', 'OR_indoors and DRIVE_-_I_M_A_PASSENGER', 'LOC_home and DRESSING', 'SITTING and AT_SCHOOL', 'COMPUTER_WORK and STAIRS_-_GOING_DOWN', 'FIX_running and SLEEPING', 'DRIVE_-_I_M_A_PASSENGER and AT_THE_GYM', 'OR_outside and PHONE_IN_POCKET', 'LOC_main_workplace and DRIVE_-_I_M_A_PASSENGER', 'ON_A_BUS and PHONE_IN_BAG', 'OR_exercise and BATHING_-_SHOWER', 'SLEEPING and COMPUTER_WORK', 'DRIVE_-_I_M_A_PASSENGER and SURFING_THE_INTERNET', 'OR_exercise and WITH_CO-WORKERS', 'LYING_DOWN and BATHING_-_SHOWER', 'DRINKING__ALCOHOL_ and WITH_CO-WORKERS', 'BATHING_-_SHOWER and LOC_beach', 'COOKING and STROLLING', 'LOC_home and LOC_beach', 'FIX_restaurant and COMPUTER_WORK', 'LOC_home and CLEANING', 'PHONE_IN_POCKET and PHONE_ON_TABLE', 'OR_exercise and GROOMING', 'BICYCLING and CLEANING', 'LYING_DOWN and PHONE_ON_TABLE', 'COMPUTER_WORK and PHONE_IN_HAND', 'FIX_walking and AT_THE_GYM', 'OR_indoors and OR_outside', 'AT_A_PARTY and AT_A_BAR', 'STAIRS_-_GOING_DOWN and AT_SCHOOL', 'AT_THE_GYM and PHONE_ON_TABLE', 'LYING_DOWN and SURFING_THE_INTERNET', 'LOC_home and OR_exercise', 'DRINKING__ALCOHOL_ and SINGING', 'DOING_LAUNDRY and LOC_beach', 'SITTING and OR_exercise', 'FIX_running and IN_A_MEETING', 'BICYCLING and STROLLING', 'FIX_restaurant and GROOMING', 'AT_A_BAR and WITH_CO-WORKERS', 'DRINKING__ALCOHOL_ and AT_A_BAR', 'OR_outside and TALKING', 'LAB_WORK and LOC_main_workplace', 'DRINKING__ALCOHOL_ and WITH_FRIENDS', 'LOC_main_workplace and SURFING_THE_INTERNET', 'PHONE_IN_POCKET and WATCHING_TV', 'TALKING and STAIRS_-_GOING_UP', 'OR_outside and AT_A_PARTY', 'SITTING and OR_indoors', 'LYING_DOWN and STAIRS_-_GOING_UP', 'LYING_DOWN and PHONE_IN_HAND', 'IN_A_CAR and STAIRS_-_GOING_DOWN', 'COOKING and AT_A_BAR', 'DOING_LAUNDRY and GROOMING', 'FIX_running and PHONE_IN_POCKET', 'LOC_home and AT_A_PARTY', 'LAB_WORK and DRINKING__ALCOHOL_', 'COOKING and WASHING_DISHES', 'STAIRS_-_GOING_UP and ELEVATOR', 'LYING_DOWN and TALKING', 'OR_exercise and STROLLING', 'PHONE_IN_POCKET and PHONE_IN_HAND', 'DRINKING__ALCOHOL_ and CLEANING', 'IN_A_CAR and PHONE_IN_BAG', 'OR_exercise and PHONE_ON_TABLE', 'BATHING_-_SHOWER and TALKING', 'COMPUTER_WORK and STAIRS_-_GOING_UP', 'EATING and DRESSING', 'SITTING and DRINKING__ALCOHOL_', 'OR_exercise and STAIRS_-_GOING_DOWN', 'SLEEPING and SHOPPING', 'OR_standing and PHONE_IN_BAG', 'OR_indoors and WATCHING_TV', 'AT_A_BAR and STAIRS_-_GOING_DOWN', 'WATCHING_TV and AT_SCHOOL', 'SHOPPING and PHONE_IN_BAG', 'AT_THE_GYM and ELEVATOR', 'LAB_WORK and OR_standing', 'IN_A_MEETING and OR_indoors', 'WATCHING_TV and AT_A_PARTY', 'SINGING and AT_SCHOOL', 'FIX_walking and LOC_main_workplace', 'IN_A_CAR and WASHING_DISHES', 'COOKING and PHONE_IN_HAND', 'FIX_walking and SLEEPING', 'AT_A_PARTY and EATING', 'AT_THE_GYM and WITH_CO-WORKERS', 'SINGING and PHONE_IN_BAG', 'CLEANING and TALKING', 'ON_A_BUS and AT_A_PARTY', 'SURFING_THE_INTERNET and WITH_CO-WORKERS', 'TALKING and WITH_CO-WORKERS', 'DRIVE_-_I_M_A_PASSENGER and AT_A_BAR', 'ON_A_BUS and LOC_home', 'FIX_running and DRIVE_-_I_M_A_PASSENGER', 'DOING_LAUNDRY and DRESSING', 'PHONE_IN_POCKET and AT_A_PARTY', 'SHOPPING and PHONE_ON_TABLE', 'TOILET and PHONE_IN_BAG', 'LYING_DOWN and OR_outside', 'OR_indoors and STROLLING', 'SLEEPING and OR_indoors', 'PHONE_IN_POCKET and STROLLING', 'SITTING and OR_standing', 'FIX_walking and ELEVATOR', 'IN_CLASS and FIX_restaurant', 'OR_outside and DOING_LAUNDRY', 'TOILET and PHONE_ON_TABLE', 'BICYCLING and LOC_beach', 'SLEEPING and AT_THE_GYM', 'AT_A_PARTY and SINGING', 'LAB_WORK and AT_SCHOOL', 'DRIVE_-_I_M_A_PASSENGER and STAIRS_-_GOING_DOWN', 'FIX_walking and WITH_CO-WORKERS', 'LOC_home and ELEVATOR', 'LAB_WORK and DRIVE_-_I_M_A_PASSENGER', 'COOKING and WATCHING_TV', 'DRIVE_-_I_M_THE_DRIVER and FIX_restaurant', 'COMPUTER_WORK and AT_THE_GYM', 'SITTING and FIX_walking', 'DRIVE_-_I_M_A_PASSENGER and SHOPPING', 'IN_CLASS and SURFING_THE_INTERNET', 'IN_CLASS and DRINKING__ALCOHOL_', 'IN_CLASS and AT_SCHOOL', 'LYING_DOWN and STAIRS_-_GOING_DOWN', 'COOKING and AT_A_PARTY', 'DRINKING__ALCOHOL_ and ELEVATOR', 'LAB_WORK and STAIRS_-_GOING_UP', 'SLEEPING and IN_A_MEETING', 'BICYCLING and LOC_main_workplace', 'SITTING and EATING', 'CLEANING and EATING', 'SLEEPING and WITH_CO-WORKERS', 'OR_indoors and SINGING', 'OR_indoors and TALKING', 'DRINKING__ALCOHOL_ and TOILET', 'BATHING_-_SHOWER and WATCHING_TV', 'BICYCLING and OR_standing', 'FIX_restaurant and TALKING', 'IN_CLASS and STAIRS_-_GOING_DOWN', 'FIX_restaurant and STAIRS_-_GOING_UP', 'BICYCLING and WITH_FRIENDS', 'DRIVE_-_I_M_THE_DRIVER and DOING_LAUNDRY', 'IN_A_CAR and STAIRS_-_GOING_UP', 'DOING_LAUNDRY and TOILET', 'WASHING_DISHES and WITH_CO-WORKERS', 'LAB_WORK and AT_THE_GYM', 'CLEANING and WATCHING_TV', 'IN_A_CAR and ELEVATOR', 'FIX_running and AT_A_BAR', 'IN_CLASS and DRIVE_-_I_M_THE_DRIVER', 'STROLLING and AT_THE_GYM', 'DRIVE_-_I_M_A_PASSENGER and BATHING_-_SHOWER', 'OR_exercise and AT_A_PARTY', 'DRIVE_-_I_M_A_PASSENGER and TOILET', 'SITTING and BICYCLING', 'OR_indoors and BATHING_-_SHOWER', 'FIX_running and LOC_beach', 'SHOPPING and CLEANING', 'DRINKING__ALCOHOL_ and PHONE_ON_TABLE', 'OR_outside and ELEVATOR', 'IN_A_MEETING and AT_SCHOOL', 'BICYCLING and IN_CLASS', 'BICYCLING and COMPUTER_WORK', 'SHOPPING and AT_A_BAR', 'FIX_restaurant and PHONE_IN_HAND', 'WASHING_DISHES and LOC_beach', 'OR_standing and WITH_FRIENDS', 'LAB_WORK and CLEANING', 'OR_exercise and CLEANING', 'WATCHING_TV and SURFING_THE_INTERNET', 'LOC_main_workplace and PHONE_IN_POCKET', 'IN_A_MEETING and IN_A_CAR', 'BICYCLING and PHONE_ON_TABLE', 'SITTING and LOC_main_workplace', 'IN_CLASS and PHONE_IN_HAND', 'SLEEPING and PHONE_ON_TABLE', 'LOC_beach and ELEVATOR', 'DRIVE_-_I_M_THE_DRIVER and DRIVE_-_I_M_A_PASSENGER', 'COMPUTER_WORK and AT_SCHOOL', 'AT_A_BAR and COMPUTER_WORK', 'TALKING and COMPUTER_WORK', 'IN_A_MEETING and STAIRS_-_GOING_DOWN', 'LOC_main_workplace and STROLLING', 'OR_exercise and STAIRS_-_GOING_UP', 'PHONE_IN_BAG and WITH_FRIENDS', 'IN_A_MEETING and WASHING_DISHES', 'IN_CLASS and OR_exercise', 'TALKING and GROOMING', 'DRIVE_-_I_M_A_PASSENGER and COMPUTER_WORK', 'DRIVE_-_I_M_A_PASSENGER and PHONE_IN_HAND', 'SITTING and STROLLING', 'SURFING_THE_INTERNET and PHONE_IN_BAG', 'TOILET and STAIRS_-_GOING_DOWN', 'LOC_main_workplace and PHONE_IN_BAG', 'LOC_beach and PHONE_ON_TABLE', 'DRIVE_-_I_M_THE_DRIVER and OR_standing', 'STROLLING and PHONE_IN_BAG', 'TOILET and ELEVATOR', 'GROOMING and AT_SCHOOL', 'DRIVE_-_I_M_THE_DRIVER and STAIRS_-_GOING_DOWN', 'DOING_LAUNDRY and WITH_CO-WORKERS', 'EATING and TOILET', 'DOING_LAUNDRY and SINGING', 'IN_A_MEETING and BATHING_-_SHOWER', 'SLEEPING and EATING', 'TALKING and PHONE_ON_TABLE', 'IN_A_MEETING and SURFING_THE_INTERNET', 'SLEEPING and WATCHING_TV', 'SURFING_THE_INTERNET and SINGING', 'SLEEPING and LOC_home', 'SLEEPING and OR_standing', 'STAIRS_-_GOING_DOWN and WITH_CO-WORKERS', 'AT_A_BAR and STAIRS_-_GOING_UP', 'SINGING and PHONE_ON_TABLE', 'OR_outside and EATING', 'LOC_beach and WITH_FRIENDS', 'LOC_home and BATHING_-_SHOWER', 'SITTING and DOING_LAUNDRY', 'STAIRS_-_GOING_DOWN and PHONE_IN_BAG', 'OR_indoors and AT_A_BAR', 'IN_CLASS and EATING', 'FIX_running and WITH_CO-WORKERS', 'SHOPPING and WITH_FRIENDS', 'IN_A_CAR and WITH_CO-WORKERS', 'BICYCLING and AT_THE_GYM', 'WATCHING_TV and SINGING', 'LYING_DOWN and GROOMING', 'FIX_restaurant and PHONE_IN_POCKET', 'SLEEPING and ON_A_BUS', 'OR_outside and COOKING', 'DRIVE_-_I_M_A_PASSENGER and DOING_LAUNDRY', 'DRESSING and PHONE_IN_BAG', 'EATING and ELEVATOR', 'FIX_restaurant and EATING', 'OR_outside and SHOPPING', 'FIX_running and OR_standing', 'BICYCLING and PHONE_IN_BAG', 'AT_SCHOOL and PHONE_IN_HAND', 'DRIVE_-_I_M_THE_DRIVER and SINGING', 'IN_CLASS and BATHING_-_SHOWER', 'SINGING and WITH_CO-WORKERS', 'IN_A_CAR and CLEANING', 'LOC_main_workplace and PHONE_IN_HAND', 'BATHING_-_SHOWER and STAIRS_-_GOING_DOWN', 'FIX_restaurant and STROLLING', 'ELEVATOR and PHONE_ON_TABLE', 'COMPUTER_WORK and OR_standing', 'STROLLING and SURFING_THE_INTERNET', 'WATCHING_TV and TALKING', 'SITTING and GROOMING', 'SINGING and STAIRS_-_GOING_DOWN', 'OR_indoors and WASHING_DISHES', 'DRIVE_-_I_M_THE_DRIVER and GROOMING', 'DRESSING and ELEVATOR', 'DRESSING and PHONE_IN_HAND', 'FIX_walking and OR_indoors', 'AT_THE_GYM and PHONE_IN_BAG', 'IN_A_MEETING and AT_THE_GYM', 'OR_exercise and OR_standing', 'LOC_beach and AT_THE_GYM', 'DRIVE_-_I_M_THE_DRIVER and SHOPPING', 'ON_A_BUS and OR_exercise', 'LAB_WORK and SHOPPING', 'SURFING_THE_INTERNET and AT_A_PARTY', 'FIX_walking and OR_standing', 'BICYCLING and OR_exercise', 'LAB_WORK and DRESSING', 'PHONE_IN_POCKET and LOC_beach', 'FIX_walking and DOING_LAUNDRY', 'LOC_main_workplace and OR_outside', 'LOC_main_workplace and DRESSING', 'COOKING and TALKING', 'BATHING_-_SHOWER and COMPUTER_WORK', 'BATHING_-_SHOWER and AT_SCHOOL', 'FIX_running and AT_A_PARTY', 'FIX_running and DRESSING', 'SURFING_THE_INTERNET and DRESSING', 'EATING and PHONE_IN_HAND', 'SHOPPING and DOING_LAUNDRY', 'OR_indoors and CLEANING', 'DRESSING and PHONE_ON_TABLE', 'AT_A_PARTY and GROOMING', 'COOKING and AT_THE_GYM', 'OR_outside and GROOMING', 'IN_A_CAR and DRINKING__ALCOHOL_', 'FIX_restaurant and CLEANING', 'AT_A_PARTY and STAIRS_-_GOING_UP', 'IN_CLASS and STAIRS_-_GOING_UP', 'WATCHING_TV and PHONE_IN_BAG', 'SITTING and AT_THE_GYM', 'OR_exercise and DRESSING', 'DOING_LAUNDRY and PHONE_ON_TABLE', 'STAIRS_-_GOING_UP and OR_standing', 'COOKING and STAIRS_-_GOING_UP', 'AT_A_PARTY and TALKING', 'LYING_DOWN and IN_A_MEETING', 'SHOPPING and STAIRS_-_GOING_UP', 'SHOPPING and WITH_CO-WORKERS', 'BICYCLING and PHONE_IN_HAND', 'OR_outside and SINGING', 'DOING_LAUNDRY and STAIRS_-_GOING_DOWN', 'BICYCLING and ON_A_BUS', 'ON_A_BUS and EATING', 'LYING_DOWN and PHONE_IN_BAG', 'BICYCLING and IN_A_CAR', 'IN_A_MEETING and PHONE_ON_TABLE', 'LAB_WORK and LOC_beach', 'ON_A_BUS and WITH_FRIENDS'}

Pie chart of labels¶

In [22]:
with gzip.open('cleaned_data.zip','rb') as file:
    feature_data = pd.read_csv(file,index_col=[0,1])

with gzip.open('new_label_data.zip','rb') as file:
    new_label_data = pd.read_csv(file,index_col=[0,1])

data = pd.concat([feature_data,new_label_data],join='inner',ignore_index=False,axis=1)

new_label_pair = data.iloc[:,-1].value_counts().index
new_label_count = data.iloc[:,-1].value_counts().values

new_label_dict = {0:'Sleep', 1:'Efficiency', 2:'Exercise', 3:'Life_activity', 4:'Entertainment', 5:'On_the_way', 6:'Normal'}
new_label_pair = [new_label_dict.get(i) for i in new_label_pair]

print(new_label_count)
plt.figure(figsize=(10,10))
plt.pie(new_label_count,labels = new_label_pair, autopct = '%.1f%%')
plt.rcParams.update({"font.size":20})
plt.axis('equal')
plt.show()

[76307 76282 59461 26862 21555 21197  9891]

Bar plot of new labels¶

In [23]:
x = np.arange(0,7)
y = new_label_data.value_counts().sort_index()
plt.bar(x,y)
plt.xlabel('labels (different number indicate different labels)')
plt.ylabel('number of data with the label')
Out[23]:
Text(0, 0.5, 'number of data with the label')

Data distribution & time series¶

In [24]:
uuid = data.groupby('uuid').count().index[36]
timestamps = data.loc[uuid].index.values
values = data.loc[uuid].iloc[:,:-1]
daytimes = []
for time in timestamps:
    daytimes.append((time - timestamps[0])/float(60*60*24))

feature_number = len(values.columns)
feature_list = [1,5,18,47]
for i in feature_list:
    feature_value = values[values.columns[i]]
    fig = plt.figure(figsize=(20,5))
    ax1 = plt.subplot(1,3,1)
    ax1.plot(daytimes,feature_value,'.-')
    ax2 = plt.subplot(1,3,2)
    feature_value.plot.box()
    ax3 = plt.subplot(1,3,3)
    ax3.hist(feature_value,bins = 50)
plt.grid(linestyle = "--", alpha=0.3)

plt.show()
#print(values.describe())

Relative Position data from Accelerometer¶

In [25]:
uuid_data = data.loc[uuid]
acc = uuid_data.iloc[:,1:4]
label = uuid_data.iloc[:,-1]
label_type = uuid_data.iloc[:,-1].value_counts().index


new_label_dict = {0:'Sleep', 1:'Efficiency', 2:'Exercise', 3:'Life_activity', 4:'Entertainment', 5:'On_the_way', 6:'Normal'}


fig = plt.figure(figsize=(20,20))
colors = ['#ff7f0e','#1f77b4',  '#2ca02c', '#d62728', '#9467bd', '#8c564b', '#e377c2', '#7f7f7f', '#bcbd22', '#17becf']
markers = ['o','s','P','X','*','p','D']
plt.rcParams.update({"font.size":20})
fig = plt.axes(projection='3d')
for i in range(7):
    index = label[label.values == i].index
    fig.scatter(acc.loc[index].iloc[:,0],acc.loc[index].iloc[:,1],acc.loc[index].iloc[:,2],label=new_label_dict[i],marker=markers[i],c=colors[i])

plt.legend()
plt.title('Relative Position data from Accelerometer',fontsize=40)

plt.show()

Absolute Position data from Accelerometer in 1 day¶

In [26]:
def get_sum_list(slice_df):
    to_list = list(slice_df)
    for i in range(len(to_list)):
        to_list[0] = 0
        to_list[i] = to_list[i-1] + to_list[i]
    return to_list

uuid_data = data.loc[uuid].iloc[:1000,:]
acc = uuid_data.iloc[:,1:4]
label = uuid_data.iloc[:,-1]
label_type = uuid_data.iloc[:,-1].value_counts().index


for i in range(3):
    acc.iloc[:,i] = get_sum_list(acc.iloc[:,i])

new_label_dict = {0:'Sleep', 1:'Efficiency', 2:'Exercise', 3:'Life_activity', 4:'Entertainment', 5:'On_the_way', 6:'Normal'}
label = uuid_data.iloc[:,-1]
label_type = uuid_data.iloc[:,-1].value_counts().index

fig = plt.figure(figsize=(10,10),dpi=200)

colors = ['#ff7f0e','#1f77b4',  '#2ca02c', '#d62728', '#9467bd', '#8c564b', '#e377c2', '#7f7f7f', '#bcbd22', '#17becf']
markers = ['o','s','P','X','*','p','D']
ax2 = plt.axes(projection='3d')
for i in range(7):
    index = label[label.values == i].index
    ax2.scatter(acc.loc[index].iloc[:,0],acc.loc[index].iloc[:,1],acc.loc[index].iloc[:,2],c = colors[i],label=new_label_dict[i],marker=markers[i])
plt.rcParams.update({"font.size":10})
plt.legend(fontsize=10)
plt.title('Absolute Position data from Accelerometer in 1 day',fontsize=20)
plt.show()

ADF test¶

In [77]:
with gzip.open('cleaned_data.zip','rb')as file:
    cleaned_data = pd.read_csv(file, index_col=[0,1])

cleaned_uuid = []
for i in cleaned_data.index:
    cleaned_uuid.append(i[0])
cleaned_uuid = list(set(cleaned_uuid))
In [45]:
from statsmodels.tsa.stattools import adfuller

uuid_nan = pd.DataFrame(
  columns = cleaned_data.columns,
  index = cleaned_uuid
)

uuid_stationary = pd.DataFrame(
  columns = [x for x in cleaned_data.columns if 'discrete' not in x],
  index = cleaned_uuid
)


# Run all cleaned_uuid
for i in range(len(cleaned_uuid)):    
    temp_data = cleaned_data.loc[cleaned_uuid[i]]
    
    # Run all Main Feature
    for feature_name in cleaned_data.columns:
        # Create uuid_nan dataframe to check the number of missing values
        uuid_nan.loc[cleaned_uuid[i],feature_name] = np.isnan(temp_data[feature_name]).sum()
        
        # ADF Test without discrete feature
        if 'discrete' not in feature_name:            
            result = adfuller(temp_data[feature_name])

            # Create uuid_stationary dataframe to check stationary
            if result[1] < 0.05:
                uuid_stationary.loc[cleaned_uuid[i],feature_name] = "Stationary"
            else:
                uuid_stationary.loc[cleaned_uuid[i],feature_name] = "False"
In [46]:
counts = uuid_stationary.apply(pd.Series.value_counts)
counts = counts.fillna(0)
# create bar plot
fig, ax = plt.subplots(figsize=(30, 10))
plt.bar(counts.columns, counts.iloc[1,:]+counts.iloc[0,:],color = 'bisque')
plt.bar(range(len(counts.columns)), counts.iloc[0,:],color = 'peru')

# plt.xticks(range(len(counts.columns)), counts.columns,rotation=90)
plt.xticks([])
plt.title('ADF test result for 52 UUIDs')
plt.legend(['Stationary','False'])
plt.xlabel('Feature data')
plt.ylabel('UUID counts')
plt.rcParams.update({"font.size":30})
plt.legend(['Stationary','False'], fontsize=30)
plt.show()

ACF and PACF plot¶

In [78]:
from statsmodels.graphics.tsaplots import plot_acf as acf
from statsmodels.graphics.tsaplots import plot_pacf as pacf
"""
this method is to plot the auto correlation figure
input: The data series to plot.(an attribute in a dataframe in this project. e.g. df['attribute'])
"""
def AutoCorrelation(data):
    fig, axs = plt.subplots(2,1,figsize=(10,10))
    plt.rcParams.update({"font.size":10})
    plt.legend(fontsize=10)
    plt.rc('xtick', labelsize=10)
    plt.rc('ytick', labelsize=10)
    acf(data,ax = axs[0], alpha = .05, use_vlines = True, title = 'acf autocorrelation')
    pacf(data,ax = axs[1], alpha = .05, use_vlines = True, title = 'pacf autocorrelation', method = 'ywm')
    plt.show()

AutoCorrelation(X['raw_acc:magnitude_stats:mean'])

No artists with labels found to put in legend.  Note that artists whose label start with an underscore are ignored when legend() is called with no argument.

Correlation Analysis for Audio Data¶

we plot the heat map of correlation matrix with audio data

In [48]:
with gzip.open('cleaned_data.zip','rb') as file:
    feature_data = pd.read_csv(file,index_col=[0,1])
audio_data = feature_data[feature_data.columns[feature_data.columns.str.startswith('audio_naive:')]]
# audio_data['uuid'] = audio_data.index.get_level_values('uuid')
uuid_audio = audio_data.groupby('uuid').count().index
audio_data_uuid = audio_data.loc[uuid_audio[36]]

audio_data_uuid -= np.mean(audio_data_uuid, axis=0)
audio_data_uuid /= np.std(audio_data_uuid, axis = 0)

audio_data_uuid.columns = [i[12:-5] for i in audio_data_uuid.columns]
In [49]:
import seaborn as sns
import matplotlib.pyplot as plt
sns.set_style('whitegrid') 
g = sns.PairGrid(audio_data_uuid, diag_sharey=False)
g.map_upper(sns.kdeplot,fill = True, bw_adjust = 1)
g.map_lower(sns.kdeplot)
g.map_diag(sns.kdeplot)
Out[49]:
<seaborn.axisgrid.PairGrid at 0x28893c35a60>
In [50]:
import seaborn as sns
# audio_data['uuid'] = audio_data.index.get_level_values('uuid')
uuid_audio = audio_data.groupby('uuid').count().index
audio_data_uuid = audio_data.loc[uuid_audio]
audio_data_uuid -= np.mean(audio_data_uuid, axis=0)
audio_data_uuid /= np.std(audio_data_uuid, axis = 0)
audio_data_uuid.columns = [i[12:-5] for i in audio_data_uuid.columns]
main_feature = []
f = open('Main Feature.txt', 'r')
for line in f.readlines():
    main_feature.append(line.strip())
main_feature.append('Status')
import matplotlib.pyplot as plt
plt.figure(figsize=(20,15))
sns.set(context='notebook', style='ticks', font_scale=2,)
ax = sns.heatmap(audio_data_uuid.corr(), cmap=sns.cubehelix_palette(as_cmap=True))
ax.set_xticklabels(ax.get_xticklabels(),rotation = 30)
# plt.xticks([])
plt.show()

PCA for Audio Data¶

This part is using principle component analysis to reduce the dimension of audio data

In [51]:
from sklearn.decomposition import PCA
import seaborn as sns
def pca_to_data(csv_df,n):

    pca = PCA(n_components=n)
    features = csv_df.loc[:,csv_df.columns.str.startswith('audio_naive')]
    new_features = pca.fit_transform(features)
    pca_components = pca.components_
    eigenvalues = pca.explained_variance_ratio_

    print('PCA explained variance ratio is', pca.explained_variance_ratio_.sum())

    new_feature_df = pd.DataFrame(data=new_features,index=csv_df.index,columns=range(n))
    other_features = csv_df.loc[:,(csv_df.columns.str.startswith('audio_naive') == False)]
    new_feature_df = pd.concat([other_features,new_feature_df],axis=1,ignore_index=False)


    return (new_feature_df, pca_components,eigenvalues)

new_feature_df, pca_components,eigenvalues = pca_to_data(audio_data,13)
sns.set_style('whitegrid') 
plt.figure(figsize=(15,10))
g = sns.lineplot(np.cumsum(eigenvalues))
g.set_xticks(range(13))
g.set_xticklabels(['PC%s'% str(i+1) for i in range(13)])
plt.xlabel('Number of Principle Components')
plt.ylabel('Cumulative Explained Variance Ratio')
plt.show()
sns.set(font_scale=1)

PCA explained variance ratio is 1.0

Model¶

In [79]:
import lightgbm as lgb
import tensorflow as tf
import keras

from tensorflow import keras
from tensorflow.keras import layers
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, LSTM, BatchNormalization
from keras.layers import Dense
from keras.layers import Dropout
from keras.models import Sequential
from sklearn.metrics import *
from sklearn import metrics
from sklearn.utils.class_weight import compute_class_weight
from xgboost import XGBClassifier


with gzip.open('cleaned_data.zip','rb') as file:
    feature_data = pd.read_csv(file,index_col=[0,1])

with gzip.open('new_label_data.zip','rb') as file:
    new_label_data = pd.read_csv(file,index_col=[0,1])

Final_data = pd.concat([feature_data,new_label_data],join='inner',ignore_index=False,axis=1)

eXtreme Gradient Boosting (XGBoost)¶

In [53]:
# 80% for training, 10% for validation, 10% for testing
x_train, y_train, x_val, y_val, x_test, y_test = splitdata(Final_data, 0.1)

# Build XGBoost Model
best_xgboost = XGBClassifier(
objective="multi:softmax",
num_class= 7
)


# Fit XGBoost model
best_xgboost.fit(x_train, y_train, eval_set=[(x_val, y_val)], eval_metric= "mlogloss", verbose=True, early_stopping_rounds=100)


# Model prediction
y_pred = best_xgboost.predict(x_test)


# Convert labels into easy-to-view form
new_label_dict = {0:'Sleep', 1:'Efficiency', 2:'Exercise', 3:'Life_activity', 4:'Entertainment', 5:'On_the_way', 6:'Normal'}
y_test_pred = [new_label_dict.get(i) for i in y_pred]
y_test_true = [new_label_dict.get(i) for i in y_test]

C:\ProgramData\Anaconda3\envs\tf\lib\site-packages\xgboost\sklearn.py:835: UserWarning: `eval_metric` in `fit` method is deprecated for better compatibility with scikit-learn, use `eval_metric` in constructor or`set_params` instead.
  warnings.warn(
C:\ProgramData\Anaconda3\envs\tf\lib\site-packages\xgboost\sklearn.py:835: UserWarning: `early_stopping_rounds` in `fit` method is deprecated for better compatibility with scikit-learn, use `early_stopping_rounds` in constructor or`set_params` instead.
  warnings.warn(

[0]	validation_0-mlogloss:1.66279
[1]	validation_0-mlogloss:1.50392
[2]	validation_0-mlogloss:1.39201
[3]	validation_0-mlogloss:1.31237
[4]	validation_0-mlogloss:1.24669
[5]	validation_0-mlogloss:1.19376
[6]	validation_0-mlogloss:1.15288
[7]	validation_0-mlogloss:1.11826
[8]	validation_0-mlogloss:1.08739
[9]	validation_0-mlogloss:1.06265
[10]	validation_0-mlogloss:1.03839
[11]	validation_0-mlogloss:1.01176
[12]	validation_0-mlogloss:0.98987
[13]	validation_0-mlogloss:0.97226
[14]	validation_0-mlogloss:0.95510
[15]	validation_0-mlogloss:0.94159
[16]	validation_0-mlogloss:0.92777
[17]	validation_0-mlogloss:0.91506
[18]	validation_0-mlogloss:0.90152
[19]	validation_0-mlogloss:0.89221
[20]	validation_0-mlogloss:0.88124
[21]	validation_0-mlogloss:0.87236
[22]	validation_0-mlogloss:0.86422
[23]	validation_0-mlogloss:0.85744
[24]	validation_0-mlogloss:0.84710
[25]	validation_0-mlogloss:0.83925
[26]	validation_0-mlogloss:0.83104
[27]	validation_0-mlogloss:0.82448
[28]	validation_0-mlogloss:0.81857
[29]	validation_0-mlogloss:0.80838
[30]	validation_0-mlogloss:0.80194
[31]	validation_0-mlogloss:0.79633
[32]	validation_0-mlogloss:0.79110
[33]	validation_0-mlogloss:0.78561
[34]	validation_0-mlogloss:0.78062
[35]	validation_0-mlogloss:0.77518
[36]	validation_0-mlogloss:0.76910
[37]	validation_0-mlogloss:0.76500
[38]	validation_0-mlogloss:0.75805
[39]	validation_0-mlogloss:0.75299
[40]	validation_0-mlogloss:0.74937
[41]	validation_0-mlogloss:0.74570
[42]	validation_0-mlogloss:0.74103
[43]	validation_0-mlogloss:0.73694
[44]	validation_0-mlogloss:0.73323
[45]	validation_0-mlogloss:0.72807
[46]	validation_0-mlogloss:0.72472
[47]	validation_0-mlogloss:0.72050
[48]	validation_0-mlogloss:0.71750
[49]	validation_0-mlogloss:0.71455
[50]	validation_0-mlogloss:0.71125
[51]	validation_0-mlogloss:0.70841
[52]	validation_0-mlogloss:0.70450
[53]	validation_0-mlogloss:0.70172
[54]	validation_0-mlogloss:0.69803
[55]	validation_0-mlogloss:0.69493
[56]	validation_0-mlogloss:0.69107
[57]	validation_0-mlogloss:0.68748
[58]	validation_0-mlogloss:0.68533
[59]	validation_0-mlogloss:0.68023
[60]	validation_0-mlogloss:0.67765
[61]	validation_0-mlogloss:0.67436
[62]	validation_0-mlogloss:0.67001
[63]	validation_0-mlogloss:0.66703
[64]	validation_0-mlogloss:0.66338
[65]	validation_0-mlogloss:0.66061
[66]	validation_0-mlogloss:0.65798
[67]	validation_0-mlogloss:0.65496
[68]	validation_0-mlogloss:0.65247
[69]	validation_0-mlogloss:0.64992
[70]	validation_0-mlogloss:0.64727
[71]	validation_0-mlogloss:0.64448
[72]	validation_0-mlogloss:0.64082
[73]	validation_0-mlogloss:0.63806
[74]	validation_0-mlogloss:0.63623
[75]	validation_0-mlogloss:0.63402
[76]	validation_0-mlogloss:0.63180
[77]	validation_0-mlogloss:0.62939
[78]	validation_0-mlogloss:0.62800
[79]	validation_0-mlogloss:0.62606
[80]	validation_0-mlogloss:0.62389
[81]	validation_0-mlogloss:0.62194
[82]	validation_0-mlogloss:0.61965
[83]	validation_0-mlogloss:0.61789
[84]	validation_0-mlogloss:0.61539
[85]	validation_0-mlogloss:0.61358
[86]	validation_0-mlogloss:0.61143
[87]	validation_0-mlogloss:0.61005
[88]	validation_0-mlogloss:0.60813
[89]	validation_0-mlogloss:0.60625
[90]	validation_0-mlogloss:0.60437
[91]	validation_0-mlogloss:0.60232
[92]	validation_0-mlogloss:0.60061
[93]	validation_0-mlogloss:0.59888
[94]	validation_0-mlogloss:0.59748
[95]	validation_0-mlogloss:0.59527
[96]	validation_0-mlogloss:0.59292
[97]	validation_0-mlogloss:0.59161
[98]	validation_0-mlogloss:0.58975
[99]	validation_0-mlogloss:0.58749

XGBoost model results¶

Accuracy, Precision, Recall, F1-score¶
In [54]:
XGBoost_acc = accuracy_score(y_test, y_pred)

print("The accuracy of XGBoost model: %.3f%%" % (XGBoost_acc * 100.0), "\n")
print(classification_report(y_test_true, y_test_pred))

The accuracy of XGBoost model: 81.571% 

               precision    recall  f1-score   support

   Efficiency       0.78      0.89      0.83      7594
Entertainment       0.79      0.69      0.74      2662
     Exercise       0.69      0.66      0.67      2156
Life_activity       0.75      0.55      0.64      2154
       Normal       0.78      0.79      0.79      5971
   On_the_way       0.79      0.67      0.73       959
        Sleep       0.95      0.95      0.95      7637

     accuracy                           0.82     29133
    macro avg       0.79      0.74      0.76     29133
 weighted avg       0.82      0.82      0.81     29133
Confusion Matrix Plot for XGBoost¶
In [55]:
sns.set(font_scale=1)
confusion = metrics.ConfusionMatrixDisplay.from_predictions(y_test_true,y_test_pred,cmap='Blues')
confusion.figure_.suptitle("Confusion Matrix (XGBoost)",fontsize=20)
confusion.figure_.set_size_inches(10,8)
plt.grid(False)
plt.show()

Light Gradient Boosting Machine (LGBM)¶

In [56]:
# 80% for training, 10% for validation, 10% for testing
x_train, y_train, x_val, y_val, x_test, y_test = splitdata(Final_data, 0.1)

x_train = pd.DataFrame(x_train)
x_val = pd.DataFrame(x_val)
x_test = pd.DataFrame(x_test)

y_train = pd.Series(y_train)
y_val = pd.Series(y_val)
y_test = pd.Series(y_test)

# Build LGBM Model
best_lgbm = lgb.LGBMClassifier(
task= "train",
objective= "multiclass",
metric= "multi_logloss",
verbosity= -1,
boosting_type= "gbdt",
num_class= 7, 
learning_rate= 0.1310183926864668, 
num_leaves= 1680, 
lambda_l1= 1.8343510276558088e-07, 
lambda_l2= 6.066153585423825e-07, 
feature_fraction= 0.8804467412053221, 
bagging_fraction= 0.9809569454316385, 
bagging_freq= 3, 
min_child_samples= 71
)

# Fit LGBM model
best_lgbm.fit(x_train, y_train, eval_set=[(x_val, y_val)], eval_metric= "multi_logloss", early_stopping_rounds=100)

# Model prediction
y_pred = best_lgbm.predict(x_test)

# Convert labels into easy-to-view form
y_test_pred = [new_label_dict.get(i) for i in y_pred]
y_test_true = [new_label_dict.get(i) for i in y_test]

C:\ProgramData\Anaconda3\envs\tf\lib\site-packages\lightgbm\sklearn.py:726: UserWarning: 'early_stopping_rounds' argument is deprecated and will be removed in a future release of LightGBM. Pass 'early_stopping()' callback via 'callbacks' argument instead.
  _log_warning("'early_stopping_rounds' argument is deprecated and will be removed in a future release of LightGBM. "

[LightGBM] [Warning] feature_fraction is set=0.8804467412053221, colsample_bytree=1.0 will be ignored. Current value: feature_fraction=0.8804467412053221
[LightGBM] [Warning] lambda_l1 is set=1.8343510276558088e-07, reg_alpha=0.0 will be ignored. Current value: lambda_l1=1.8343510276558088e-07
[LightGBM] [Warning] bagging_fraction is set=0.9809569454316385, subsample=1.0 will be ignored. Current value: bagging_fraction=0.9809569454316385
[LightGBM] [Warning] lambda_l2 is set=6.066153585423825e-07, reg_lambda=0.0 will be ignored. Current value: lambda_l2=6.066153585423825e-07
[LightGBM] [Warning] bagging_freq is set=3, subsample_freq=0 will be ignored. Current value: bagging_freq=3
[1]	valid_0's multi_logloss: 1.43109
[2]	valid_0's multi_logloss: 1.24142
[3]	valid_0's multi_logloss: 1.10138
[4]	valid_0's multi_logloss: 0.991515
[5]	valid_0's multi_logloss: 0.902744
[6]	valid_0's multi_logloss: 0.829471
[7]	valid_0's multi_logloss: 0.76925
[8]	valid_0's multi_logloss: 0.719642
[9]	valid_0's multi_logloss: 0.675652
[10]	valid_0's multi_logloss: 0.638053
[11]	valid_0's multi_logloss: 0.605434
[12]	valid_0's multi_logloss: 0.576039
[13]	valid_0's multi_logloss: 0.550489
[14]	valid_0's multi_logloss: 0.527987
[15]	valid_0's multi_logloss: 0.508183
[16]	valid_0's multi_logloss: 0.490669
[17]	valid_0's multi_logloss: 0.475275
[18]	valid_0's multi_logloss: 0.460245
[19]	valid_0's multi_logloss: 0.447055
[20]	valid_0's multi_logloss: 0.434837
[21]	valid_0's multi_logloss: 0.423823
[22]	valid_0's multi_logloss: 0.413649
[23]	valid_0's multi_logloss: 0.405403
[24]	valid_0's multi_logloss: 0.397563
[25]	valid_0's multi_logloss: 0.390061
[26]	valid_0's multi_logloss: 0.383609
[27]	valid_0's multi_logloss: 0.378463
[28]	valid_0's multi_logloss: 0.372312
[29]	valid_0's multi_logloss: 0.366677
[30]	valid_0's multi_logloss: 0.361728
[31]	valid_0's multi_logloss: 0.357605
[32]	valid_0's multi_logloss: 0.353705
[33]	valid_0's multi_logloss: 0.350125
[34]	valid_0's multi_logloss: 0.347221
[35]	valid_0's multi_logloss: 0.344404
[36]	valid_0's multi_logloss: 0.341843
[37]	valid_0's multi_logloss: 0.338767
[38]	valid_0's multi_logloss: 0.33624
[39]	valid_0's multi_logloss: 0.333871
[40]	valid_0's multi_logloss: 0.331769
[41]	valid_0's multi_logloss: 0.329394
[42]	valid_0's multi_logloss: 0.327487
[43]	valid_0's multi_logloss: 0.326313
[44]	valid_0's multi_logloss: 0.324658
[45]	valid_0's multi_logloss: 0.323099
[46]	valid_0's multi_logloss: 0.321469
[47]	valid_0's multi_logloss: 0.320042
[48]	valid_0's multi_logloss: 0.318975
[49]	valid_0's multi_logloss: 0.317687
[50]	valid_0's multi_logloss: 0.31671
[51]	valid_0's multi_logloss: 0.315738
[52]	valid_0's multi_logloss: 0.314912
[53]	valid_0's multi_logloss: 0.314079
[54]	valid_0's multi_logloss: 0.313492
[55]	valid_0's multi_logloss: 0.312817
[56]	valid_0's multi_logloss: 0.31215
[57]	valid_0's multi_logloss: 0.312021
[58]	valid_0's multi_logloss: 0.311448
[59]	valid_0's multi_logloss: 0.311175
[60]	valid_0's multi_logloss: 0.311176
[61]	valid_0's multi_logloss: 0.310837
[62]	valid_0's multi_logloss: 0.310881
[63]	valid_0's multi_logloss: 0.310758
[64]	valid_0's multi_logloss: 0.310607
[65]	valid_0's multi_logloss: 0.310773
[66]	valid_0's multi_logloss: 0.310731
[67]	valid_0's multi_logloss: 0.310598
[68]	valid_0's multi_logloss: 0.310702
[69]	valid_0's multi_logloss: 0.310742
[70]	valid_0's multi_logloss: 0.310971
[71]	valid_0's multi_logloss: 0.311623
[72]	valid_0's multi_logloss: 0.311913
[73]	valid_0's multi_logloss: 0.312259
[74]	valid_0's multi_logloss: 0.312375
[75]	valid_0's multi_logloss: 0.312722
[76]	valid_0's multi_logloss: 0.312921
[77]	valid_0's multi_logloss: 0.313443
[78]	valid_0's multi_logloss: 0.31389
[79]	valid_0's multi_logloss: 0.314509
[80]	valid_0's multi_logloss: 0.315275
[81]	valid_0's multi_logloss: 0.315901
[82]	valid_0's multi_logloss: 0.316617
[83]	valid_0's multi_logloss: 0.317137
[84]	valid_0's multi_logloss: 0.317676
[85]	valid_0's multi_logloss: 0.318231
[86]	valid_0's multi_logloss: 0.319387
[87]	valid_0's multi_logloss: 0.320096
[88]	valid_0's multi_logloss: 0.320836
[89]	valid_0's multi_logloss: 0.321422
[90]	valid_0's multi_logloss: 0.322023
[91]	valid_0's multi_logloss: 0.322786
[92]	valid_0's multi_logloss: 0.323482
[93]	valid_0's multi_logloss: 0.324428
[94]	valid_0's multi_logloss: 0.325271
[95]	valid_0's multi_logloss: 0.3261
[96]	valid_0's multi_logloss: 0.326697
[97]	valid_0's multi_logloss: 0.327421
[98]	valid_0's multi_logloss: 0.328291
[99]	valid_0's multi_logloss: 0.329406
[100]	valid_0's multi_logloss: 0.330174

LightGBM model results¶

Accuracy, Precision, Recall, F1-score¶
In [57]:
LGBM_acc = accuracy_score(y_test, y_pred)

print("The accuracy of LightGBM model: %.3f%%" % (LGBM_acc * 100.0), "\n")
print(classification_report(y_test_true, y_test_pred))

The accuracy of LightGBM model: 90.128% 

               precision    recall  f1-score   support

   Efficiency       0.89      0.95      0.92      7594
Entertainment       0.91      0.84      0.87      2662
     Exercise       0.79      0.75      0.77      2156
Life_activity       0.86      0.78      0.82      2154
       Normal       0.88      0.90      0.89      5971
   On_the_way       0.88      0.74      0.80       959
        Sleep       0.98      0.97      0.98      7637

     accuracy                           0.90     29133
    macro avg       0.88      0.85      0.86     29133
 weighted avg       0.90      0.90      0.90     29133
Confusion Matrix Plot for LightGBM¶
In [58]:
sns.set(font_scale=1)
confusion = metrics.ConfusionMatrixDisplay.from_predictions(y_test_true,y_test_pred,cmap='Blues')
confusion.figure_.suptitle("Confusion Matrix (LightGBM)",fontsize=20)
confusion.figure_.set_size_inches(10,8)
plt.grid(False)
plt.show()

Neural Networks (NN)¶

In [59]:
# 80% for training, 10% for validation, 10% for testing
x_train, y_train, x_val, y_val, x_test, y_test = splitdata(Final_data, 0.1)
Final_data[main_feature[32]] = Final_data[main_feature[50]]
# Define batch size and output classes
batch_size = int(len(x_train) // 10000)
classes = 7

# Build NN model
def Build_NN():
    model = Sequential()
    
    # Hidden layer 1
    model.add(Dense(1300, activation='relu'))
    model.add(Dropout(rate=0.16841380557977734))
    
    # Hidden layer 2
    model.add(Dense(2000, activation='relu'))
    model.add(Dropout(rate=0.12075541721671049))
    
    # Hidden layer 3
    model.add(Dense(1450, activation='relu'))
    model.add(Dropout(rate=0.21586172555968303))
    
    # Output layer
    model.add(Dense(classes, activation="softmax"))
    
    model.compile(
        loss = "sparse_categorical_crossentropy",
        optimizer = tf.optimizers.Adam(learning_rate = 0.00015164741842153617),
        metrics = ["accuracy"],)
    
    return model

Best_NNmodel = Build_NN()


# Fit NN model
Best_NN = Best_NNmodel.fit(
    x_train, y_train, validation_data=(x_val, y_val), batch_size=batch_size, epochs=30
)


# Model prediction
y_pred = Best_NNmodel.predict(x_test)
y_pred = np.argmax(y_pred, axis=1)

# Convert labels into easy-to-view form
y_test_pred = [new_label_dict.get(i) for i in y_pred]
y_test_true = [new_label_dict.get(i) for i in y_test]

Epoch 1/30
10139/10139 [==============================] - 48s 5ms/step - loss: 2.0073 - accuracy: 0.3659 - val_loss: 1.5024 - val_accuracy: 0.4520
Epoch 2/30
10139/10139 [==============================] - 47s 5ms/step - loss: 1.4077 - accuracy: 0.4883 - val_loss: 1.2415 - val_accuracy: 0.5466
Epoch 3/30
10139/10139 [==============================] - 47s 5ms/step - loss: 1.2233 - accuracy: 0.5568 - val_loss: 1.1047 - val_accuracy: 0.5923
Epoch 4/30
10139/10139 [==============================] - 46s 5ms/step - loss: 1.1148 - accuracy: 0.5975 - val_loss: 1.0205 - val_accuracy: 0.6278
Epoch 5/30
10139/10139 [==============================] - 47s 5ms/step - loss: 1.0447 - accuracy: 0.6209 - val_loss: 0.9557 - val_accuracy: 0.6500
Epoch 6/30
10139/10139 [==============================] - 47s 5ms/step - loss: 0.9963 - accuracy: 0.6385 - val_loss: 0.9315 - val_accuracy: 0.6571
Epoch 7/30
10139/10139 [==============================] - 47s 5ms/step - loss: 0.9569 - accuracy: 0.6521 - val_loss: 0.8798 - val_accuracy: 0.6758
Epoch 8/30
10139/10139 [==============================] - 47s 5ms/step - loss: 0.9264 - accuracy: 0.6642 - val_loss: 0.8631 - val_accuracy: 0.6810
Epoch 9/30
10139/10139 [==============================] - 47s 5ms/step - loss: 0.9052 - accuracy: 0.6719 - val_loss: 0.8309 - val_accuracy: 0.6970
Epoch 10/30
10139/10139 [==============================] - 47s 5ms/step - loss: 0.8818 - accuracy: 0.6806 - val_loss: 0.8206 - val_accuracy: 0.6990
Epoch 11/30
10139/10139 [==============================] - 47s 5ms/step - loss: 0.8652 - accuracy: 0.6874 - val_loss: 0.7990 - val_accuracy: 0.7067
Epoch 12/30
10139/10139 [==============================] - 47s 5ms/step - loss: 0.8501 - accuracy: 0.6915 - val_loss: 0.7868 - val_accuracy: 0.7085
Epoch 13/30
10139/10139 [==============================] - 47s 5ms/step - loss: 0.8372 - accuracy: 0.6981 - val_loss: 0.7719 - val_accuracy: 0.7172
Epoch 14/30
10139/10139 [==============================] - 47s 5ms/step - loss: 0.8236 - accuracy: 0.7018 - val_loss: 0.7662 - val_accuracy: 0.7266
Epoch 15/30
10139/10139 [==============================] - 46s 5ms/step - loss: 0.8112 - accuracy: 0.7066 - val_loss: 0.7457 - val_accuracy: 0.7292
Epoch 16/30
10139/10139 [==============================] - 47s 5ms/step - loss: 0.8027 - accuracy: 0.7100 - val_loss: 0.7426 - val_accuracy: 0.7286
Epoch 17/30
10139/10139 [==============================] - 51s 5ms/step - loss: 0.7930 - accuracy: 0.7131 - val_loss: 0.7223 - val_accuracy: 0.7362
Epoch 18/30
10139/10139 [==============================] - 53s 5ms/step - loss: 0.7907 - accuracy: 0.7152 - val_loss: 0.7312 - val_accuracy: 0.7299
Epoch 19/30
10139/10139 [==============================] - 47s 5ms/step - loss: 0.7821 - accuracy: 0.7183 - val_loss: 0.7211 - val_accuracy: 0.7369
Epoch 20/30
10139/10139 [==============================] - 47s 5ms/step - loss: 0.7762 - accuracy: 0.7194 - val_loss: 0.7018 - val_accuracy: 0.7454
Epoch 21/30
10139/10139 [==============================] - 46s 5ms/step - loss: 0.7751 - accuracy: 0.7225 - val_loss: 0.7045 - val_accuracy: 0.7436
Epoch 22/30
10139/10139 [==============================] - 47s 5ms/step - loss: 0.7642 - accuracy: 0.7247 - val_loss: 0.7099 - val_accuracy: 0.7414
Epoch 23/30
10139/10139 [==============================] - 47s 5ms/step - loss: 0.7637 - accuracy: 0.7257 - val_loss: 0.7092 - val_accuracy: 0.7421
Epoch 24/30
10139/10139 [==============================] - 47s 5ms/step - loss: 0.7590 - accuracy: 0.7269 - val_loss: 0.7101 - val_accuracy: 0.7437
Epoch 25/30
10139/10139 [==============================] - 47s 5ms/step - loss: 0.7532 - accuracy: 0.7285 - val_loss: 0.6892 - val_accuracy: 0.7502
Epoch 26/30
10139/10139 [==============================] - 47s 5ms/step - loss: 0.7474 - accuracy: 0.7312 - val_loss: 0.6958 - val_accuracy: 0.7483
Epoch 27/30
10139/10139 [==============================] - 47s 5ms/step - loss: 0.7441 - accuracy: 0.7324 - val_loss: 0.6726 - val_accuracy: 0.7567
Epoch 28/30
10139/10139 [==============================] - 47s 5ms/step - loss: 0.7454 - accuracy: 0.7326 - val_loss: 0.6780 - val_accuracy: 0.7530
Epoch 29/30
10139/10139 [==============================] - 47s 5ms/step - loss: 0.7370 - accuracy: 0.7346 - val_loss: 0.6789 - val_accuracy: 0.7527
Epoch 30/30
10139/10139 [==============================] - 47s 5ms/step - loss: 0.7375 - accuracy: 0.7354 - val_loss: 0.6697 - val_accuracy: 0.7529

NN model training process¶

In [60]:
acc = Best_NN.history['accuracy']
val_acc = Best_NN.history['val_accuracy']
loss = Best_NN.history['loss']
val_loss = Best_NN.history['val_loss']

sns.set(font_scale=1.5)
epochs = range(1,len(acc)+1)
fig = plt.figure(figsize=(20,10))
ax1 = fig.add_subplot(121)
ax1.plot(epochs,acc,'g',label='Trainning acc')
ax1.plot(epochs,val_acc,'b--',label='Vaildation acc')
ax1.legend()
ax1.set_title('Accuracy in each epoch',fontsize=20)
ax1.set_xlabel('Epochs',fontsize=20)
ax1.set_ylabel('Accuracy',fontsize=20)
plt.ylim(0,1)
ax2 = fig.add_subplot(122)
ax2.plot(epochs,loss,'g',label='Trainning loss')
ax2.plot(epochs,val_loss,'b--',label='Vaildation loss')
ax2.legend()
ax2.set_title('Loss in each epoch',fontsize=20)
ax2.set_xlabel('Epochs',fontsize=20)
ax2.set_ylabel('Loss',fontsize=20)
plt.ylim(0,3)
plt.show()

NN model results¶

Accuracy, Precision, Recall, F1-score¶
In [61]:
ANN_acc = accuracy_score(y_test_true, y_test_pred)

print("The accuracy of NN model: %.3f%%" % (ANN_acc * 100.0), "\n")
print(classification_report(y_test_true, y_test_pred))

The accuracy of NN model: 76.106% 

               precision    recall  f1-score   support

   Efficiency       0.69      0.88      0.77      7594
Entertainment       0.75      0.56      0.64      2662
     Exercise       0.58      0.65      0.62      2156
Life_activity       0.66      0.40      0.49      2154
       Normal       0.76      0.68      0.72      5971
   On_the_way       0.74      0.54      0.63       959
        Sleep       0.93      0.93      0.93      7637

     accuracy                           0.76     29133
    macro avg       0.73      0.66      0.69     29133
 weighted avg       0.76      0.76      0.75     29133
Confusion Matrix Plot for NN¶
In [62]:
sns.set(font_scale=1)
confusion = metrics.ConfusionMatrixDisplay.from_predictions(y_test_true,y_test_pred,cmap='Blues')
confusion.figure_.suptitle("Confusion Matrix (NN)",fontsize=20)
confusion.figure_.set_size_inches(10,8)
plt.grid(False)
plt.show()

Long Short-Term Memory (LSTM)¶

In [64]:
# We use 3 past minutes as features and we want to forecast 1 step ahead:
x_train, y_train, x_val, y_val, x_test, y_test  = TS_split(Final_data, n_past=3, n_pred=1)


print("Detailed shape of the datasets for the LSTM model")
print(f"Shape of training X: {x_train.shape}")
print(f"Shape of training Y: {y_train.shape}")

print(f"Shape of validation X: {x_val.shape}")
print(f"Shape of validation Y: {y_val.shape}")

print(f"Shape of testing X: {x_test.shape}")
print(f"Shape of testing Y: {y_test.shape}")

# Define timesteps, features, outputs classes
n_timesteps = x_train.shape[1]
n_features = x_train.shape[2]
n_outputs = 7

# Define batch size, epochs
batch_size = int(len(x_train) // 10000)
epochs=10

Detailed shape of the datasets for the LSTM model
Shape of training X: (221016, 3, 50)
Shape of training Y: (221016, 1)
Shape of validation X: (36311, 3, 50)
Shape of validation Y: (36311, 1)
Shape of testing X: (34216, 3, 50)
Shape of testing Y: (34216, 1)
In [65]:
# Build LSTM model
def Build_LSTM():
    lstm_layer = keras.layers.LSTM(100, input_shape=(n_timesteps, n_features))
    model = keras.models.Sequential(
    [
        lstm_layer,
        keras.layers.BatchNormalization(),
        
        keras.layers.Dense(45, activation='relu'),
        keras.layers.Dropout(0.2990628539770123),
        keras.layers.BatchNormalization(),
        
        keras.layers.Dense(72, activation='relu'),
        keras.layers.Dropout(0.4864208063056207),
        keras.layers.BatchNormalization(),
        
        keras.layers.Dense(153, activation='relu'),
        keras.layers.Dropout(0.39279029213912864),
        keras.layers.BatchNormalization(),
        
        keras.layers.Dense(244, activation='relu'),
        keras.layers.Dropout(0.31946249134351457),
        keras.layers.BatchNormalization(),
        
        keras.layers.Dense(n_outputs, activation='softmax', kernel_regularizer=tf.keras.regularizers.l2(6.331604373902864e-06)),
    ])
    return model


Best_LSTMmodel = Build_LSTM()
Best_LSTMmodel.compile(
    loss='sparse_categorical_crossentropy',
    optimizer = tf.optimizers.Adam(learning_rate = 0.00015164741842153617),
    metrics=["accuracy"],
)


# Fit LSTM model
Best_LSTM = Best_LSTMmodel.fit(
    x_train, y_train, validation_data=(x_val, y_val), batch_size=batch_size, epochs=10
)


# Model prediction
y_pred = Best_LSTMmodel.predict(x_test)
y_pred = np.argmax(y_pred, axis=1)

# Convert labels into easy-to-view form
y_test_pred = [new_label_dict.get(i) for i in y_pred]
y_test_true = [new_label_dict.get(int(i[0])) for i in y_test]

Epoch 1/10
10047/10047 [==============================] - 176s 17ms/step - loss: 1.8212 - accuracy: 0.3068 - val_loss: 1.7498 - val_accuracy: 0.3057
Epoch 2/10
10047/10047 [==============================] - 175s 17ms/step - loss: 1.5928 - accuracy: 0.4034 - val_loss: 1.7392 - val_accuracy: 0.3206
Epoch 3/10
10047/10047 [==============================] - 170s 17ms/step - loss: 1.5042 - accuracy: 0.4446 - val_loss: 1.8009 - val_accuracy: 0.2994
Epoch 4/10
10047/10047 [==============================] - 170s 17ms/step - loss: 1.4381 - accuracy: 0.4731 - val_loss: 1.6993 - val_accuracy: 0.3517
Epoch 5/10
10047/10047 [==============================] - 171s 17ms/step - loss: 1.2764 - accuracy: 0.5454 - val_loss: 1.1021 - val_accuracy: 0.5717
Epoch 6/10
10047/10047 [==============================] - 172s 17ms/step - loss: 0.9101 - accuracy: 0.6754 - val_loss: 0.7565 - val_accuracy: 0.7175
Epoch 7/10
10047/10047 [==============================] - 170s 17ms/step - loss: 0.6735 - accuracy: 0.7704 - val_loss: 0.4532 - val_accuracy: 0.8516
Epoch 8/10
10047/10047 [==============================] - 172s 17ms/step - loss: 0.5071 - accuracy: 0.8349 - val_loss: 0.3074 - val_accuracy: 0.9315
Epoch 9/10
10047/10047 [==============================] - 170s 17ms/step - loss: 0.4164 - accuracy: 0.8727 - val_loss: 0.2257 - val_accuracy: 0.9518
Epoch 10/10
10047/10047 [==============================] - 170s 17ms/step - loss: 0.3761 - accuracy: 0.8913 - val_loss: 0.3712 - val_accuracy: 0.8824

LSTM model training process¶

In [66]:
acc = Best_LSTM.history['accuracy']
val_acc = Best_LSTM.history['val_accuracy']
loss = Best_LSTM.history['loss']
val_loss = Best_LSTM.history['val_loss']

sns.set(font_scale=1.5)
epochs = range(1,len(acc)+1)
fig = plt.figure(figsize=(20,10))
ax1 = fig.add_subplot(121)
ax1.plot(epochs,acc,'g',label='Trainning acc')
ax1.plot(epochs,val_acc,'b--',label='Vaildation acc')
ax1.legend()
ax1.set_title('Accuracy in each epoch',fontsize=20)
ax1.set_xlabel('Epochs',fontsize=20)
ax1.set_ylabel('Accuracy',fontsize=20)
plt.ylim(0,1)
ax2 = fig.add_subplot(122)
ax2.plot(epochs,loss,'g',label='Trainning loss')
ax2.plot(epochs,val_loss,'b--',label='Vaildation loss')
ax2.legend()
ax2.set_title('Loss in each epoch',fontsize=20)
ax2.set_xlabel('Epochs',fontsize=20)
ax2.set_ylabel('Loss',fontsize=20)
plt.ylim(0,3)
plt.show()

LSTM model results¶

Accuracy, Precision, Recall, F1-score¶
In [97]:
LSTM_acc = accuracy_score(y_test_true, y_test_pred)

print("The accuracy of LSTM model: %.3f%%" % (LSTM_acc * 100.0), "\n")
print(classification_report(y_test_true, y_test_pred))

The accuracy of LSTM model: 89.958% 

               precision    recall  f1-score   support

   Efficiency       0.99      0.97      0.98      7937
Entertainment       0.88      0.74      0.81      4093
     Exercise       0.72      0.91      0.80      2194
Life_activity       0.66      0.74      0.70      2834
       Normal       0.89      0.98      0.93      8012
   On_the_way       0.90      0.14      0.25      1197
        Sleep       0.99      0.99      0.99      7949

     accuracy                           0.90     34216
    macro avg       0.86      0.78      0.78     34216
 weighted avg       0.91      0.90      0.89     34216
Confusion Matrix Plot for LSTM¶
In [68]:
sns.set(font_scale=1)
confusion = metrics.ConfusionMatrixDisplay.from_predictions(y_test_true,y_test_pred,cmap='Blues')
confusion.figure_.suptitle("Confusion Matrix (LSTM)",fontsize=20)
confusion.figure_.set_size_inches(10,8)
plt.grid(False)
plt.show()

Gated Recurrent Unit (GRU)¶

In [85]:
# We use 3 past minutes as features and we want to forecast 1 step ahead:
x_train, y_train, x_val, y_val, x_test, y_test  = TS_split(Final_data, n_past=3, n_pred=1)


print("Detailed shape of the datasets for the GRU model")
print(f"Shape of training X: {x_train.shape}")
print(f"Shape of training Y: {y_train.shape}")

print(f"Shape of validation X: {x_val.shape}")
print(f"Shape of validation Y: {y_val.shape}")

print(f"Shape of testing X: {x_test.shape}")
print(f"Shape of testing Y: {y_test.shape}")

# Define timesteps, features, outputs classes
n_timesteps = x_train.shape[1]
n_features = x_train.shape[2]
n_outputs = 7

# Define batch size, epochs, units
batch_size = int(len(x_train) // 10000)
epochs=10
units = 256

Detailed shape of the datasets for the GRU model
Shape of training X: (221016, 3, 50)
Shape of training Y: (221016, 1)
Shape of validation X: (36311, 3, 50)
Shape of validation Y: (36311, 1)
Shape of testing X: (34216, 3, 50)
Shape of testing Y: (34216, 1)
In [72]:
# Build GRU model
def Build_GRU():
    gru_layer = keras.layers.GRU(units, input_shape=(n_timesteps,n_features))
    model = keras.models.Sequential(
    [
        gru_layer,
        keras.layers.Dropout(0.406534000556442),
        keras.layers.BatchNormalization(),

        keras.layers.Dense(267, activation='relu'),
        keras.layers.Dropout(0.41292144049614665),
        keras.layers.BatchNormalization(),

        keras.layers.Dense(52, activation='relu'),
        keras.layers.Dropout(0.3921007156172197),
        keras.layers.BatchNormalization(),
        keras.layers.Dense(n_outputs, activation='softmax', kernel_regularizer=tf.keras.regularizers.l2(0.00027554973440142773)),
    ])
    return model

Best_GRUmodel = Build_GRU()
Best_GRUmodel.compile(
    loss='sparse_categorical_crossentropy',
    optimizer = tf.optimizers.Adam(learning_rate = 0.00024008062658582616),
    metrics=["accuracy"],
)


# Fit GRU model
Best_GRU = Best_GRUmodel.fit(
    x_train, y_train, validation_data=(x_val, y_val), batch_size=batch_size, epochs=10
)


# Model prediction
y_pred = Best_GRUmodel.predict(x_test)
y_pred = np.argmax(y_pred, axis=1)

# Convert labels into easy-to-view form
y_test_pred = [new_label_dict.get(i) for i in y_pred]
y_test_true = [new_label_dict.get(int(i[0])) for i in y_test]

Epoch 1/10
10047/10047 [==============================] - 112s 11ms/step - loss: 1.6589 - accuracy: 0.3843 - val_loss: 1.6681 - val_accuracy: 0.3786
Epoch 2/10
10047/10047 [==============================] - 114s 11ms/step - loss: 1.4438 - accuracy: 0.4718 - val_loss: 1.2362 - val_accuracy: 0.5973
Epoch 3/10
10047/10047 [==============================] - 113s 11ms/step - loss: 1.0499 - accuracy: 0.6233 - val_loss: 0.7801 - val_accuracy: 0.6635
Epoch 4/10
10047/10047 [==============================] - 114s 11ms/step - loss: 0.8540 - accuracy: 0.7023 - val_loss: 0.5690 - val_accuracy: 0.8301
Epoch 5/10
10047/10047 [==============================] - 116s 12ms/step - loss: 0.7540 - accuracy: 0.7448 - val_loss: 0.5066 - val_accuracy: 0.8781
Epoch 6/10
10047/10047 [==============================] - 114s 11ms/step - loss: 0.6765 - accuracy: 0.7762 - val_loss: 0.4619 - val_accuracy: 0.8675
Epoch 7/10
10047/10047 [==============================] - 113s 11ms/step - loss: 0.6160 - accuracy: 0.8009 - val_loss: 0.4120 - val_accuracy: 0.9184
Epoch 8/10
10047/10047 [==============================] - 110s 11ms/step - loss: 0.5757 - accuracy: 0.8200 - val_loss: 0.4072 - val_accuracy: 0.9158
Epoch 9/10
10047/10047 [==============================] - 115s 11ms/step - loss: 0.5565 - accuracy: 0.8286 - val_loss: 0.3784 - val_accuracy: 0.9104
Epoch 10/10
10047/10047 [==============================] - 114s 11ms/step - loss: 0.5304 - accuracy: 0.8401 - val_loss: 0.3453 - val_accuracy: 0.9158

GRU model training process¶

In [73]:
acc = Best_GRU.history['accuracy']
val_acc = Best_GRU.history['val_accuracy']
loss = Best_GRU.history['loss']
val_loss = Best_GRU.history['val_loss']

sns.set(font_scale=1.5)
epochs = range(1,len(acc)+1)
fig = plt.figure(figsize=(20,10))
ax1 = fig.add_subplot(121)
ax1.plot(epochs,acc,'g',label='Trainning acc')
ax1.plot(epochs,val_acc,'b--',label='Vaildation acc')
ax1.legend()
ax1.set_title('Accuracy in each epoch',fontsize=20)
ax1.set_xlabel('Epochs',fontsize=20)
ax1.set_ylabel('Accuracy',fontsize=20)
plt.ylim(0,1)
ax2 = fig.add_subplot(122)
ax2.plot(epochs,loss,'g',label='Trainning loss')
ax2.plot(epochs,val_loss,'b--',label='Vaildation loss')
ax2.legend()
ax2.set_title('Loss in each epoch',fontsize=20)
ax2.set_xlabel('Epochs',fontsize=20)
ax2.set_ylabel('Loss',fontsize=20)
plt.ylim(0,3)
plt.show()

GRU model results¶

Accuracy, Precision, Recall, F1-score¶
In [74]:
GRU_acc = accuracy_score(y_test_true, y_test_pred)

print("The accuracy of GRU model: %.3f%%" % (GRU_acc  * 100.0), "\n")
print(classification_report(y_test_true, y_test_pred))

The accuracy of GRU model: 88.222% 

               precision    recall  f1-score   support

   Efficiency       0.98      0.98      0.98      7937
Entertainment       0.75      0.65      0.69      4093
     Exercise       0.67      0.87      0.75      2194
Life_activity       0.56      0.64      0.60      2834
       Normal       0.94      0.97      0.95      8012
   On_the_way       0.79      0.38      0.51      1197
        Sleep       1.00      0.99      0.99      7949

     accuracy                           0.88     34216
    macro avg       0.81      0.78      0.78     34216
 weighted avg       0.89      0.88      0.88     34216
Confusion Matrix Plot for GRU¶
In [75]:
sns.set(font_scale=1)
confusion = metrics.ConfusionMatrixDisplay.from_predictions(y_test_true,y_test_pred,cmap='Blues')
confusion.figure_.suptitle("Confusion Matrix (GRU)",fontsize=20)
confusion.figure_.set_size_inches(10,8)
plt.grid(False)
plt.show()

SGDClassifier¶

In [74]:
from sklearn.multiclass import OneVsRestClassifier
from sklearn.linear_model import SGDClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
# cw = {'sleep':0.35,'exercise':0.42,'efficiency':0.25,'entertainment':0.25,'life_activity':0.25,0:10,1:0.1}
cw = {0:1,1:1,4:1,6:1,2:2.5,3:2.5,5:4}
# cw =[0.84317032,3.71747212, 0.70185289, 1.3185654,  0.73432222]
with gzip.open('cleaned_data.zip','rb') as file:
    feature_data = pd.read_csv(file,index_col=[0,1])
with gzip.open('new_label_data.zip','rb') as file:
    new_label_data = pd.read_csv(file,index_col=[0,1])
Final_data = pd.concat([feature_data,new_label_data],join='inner',ignore_index=False,axis=1)
x_train, y_train, x_val, y_val, x_test, y_test = splitdata(Final_data, 0.1)
model = OneVsRestClassifier(SGDClassifier(loss='squared_hinge',alpha = 0.001,class_weight=cw,validation_fraction=0.3,learning_rate='adaptive',eta0=1,max_iter=100000))
model.fit(x_train,pd.DataFrame(y_train))
pred = model.predict(x_test)
accuracy = model.score(x_test,y_test)
print("Accuracy of SGDClassifier on training set: ")
print(model.score(x_train,y_train))
print("Accuracy of SGDClassifier on testing set: ")
print(accuracy)

Accuracy of SGDClassifier on training set: 
0.41309883528051
Accuracy of SGDClassifier on testing set: 
0.41413517317131776

Naive bayes¶

In [75]:
from sklearn import naive_bayes
from sklearn.preprocessing import MinMaxScaler
# X_train.columns = np.arange(0,X_train.shape[1])
# X_test.columns = np.arange(0,X_test.shape[1])
scaler = MinMaxScaler()
X_train = scaler.fit_transform(x_train)
X_test = scaler.fit_transform(x_test)
cls = naive_bayes.ComplementNB(alpha=10,class_prior = [0.25,0.25,0.1,0.1,0.25,0.1,0.25])
cls.fit(X_train,y_train)#X_train,pd.DataFrame(y_train))
y_pred = cls.predict(X_test)
accuracy = cls.score(X_test,y_test)
print("Accuracy of Naive Bayes on training set: ")
print(cls.score(X_train,y_train))
print("Accuracy of Naive Bayes on testing set: ")
print(accuracy)

Accuracy of Naive Bayes on training set: 
0.3737637744443149
Accuracy of Naive Bayes on testing set: 
0.3765146054302681

Random forest¶

In [76]:
from sklearn.ensemble import RandomForestClassifier
 
clf = RandomForestClassifier(n_estimators=100, max_depth= 13,min_samples_leaf=20,max_features= 35)
clf.fit(x_train, y_train)
y_pred = clf.predict(x_test)
accuracy = clf.score(x_test,y_test)
print("Accuracy of random forest on training set: ")
print(clf.score(x_train,y_train))
print("Accuracy of random forest on testing set: ")
print(accuracy)

Accuracy of random forest on training set: 
0.7416725694662375
Accuracy of random forest on testing set: 
0.7184635979816703